]> 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
Detect Apple bug that prevents the joystick code compiling for OS X 10.1
[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 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLogChain swig_types[0]
1343 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1344 #define SWIGTYPE_p_wxFileHistory swig_types[2]
1345 #define SWIGTYPE_p_wxLog swig_types[3]
1346 #define SWIGTYPE_p_wxMenu swig_types[4]
1347 #define SWIGTYPE_p_wxEvent swig_types[5]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[6]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[7]
1350 #define SWIGTYPE_p_wxDisplay swig_types[8]
1351 #define SWIGTYPE_p_wxFileType swig_types[9]
1352 #define SWIGTYPE_p_wxLogGui swig_types[10]
1353 #define SWIGTYPE_p_wxFont swig_types[11]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[12]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[13]
1356 #define SWIGTYPE_p_wxCaret swig_types[14]
1357 #define SWIGTYPE_ptrdiff_t swig_types[15]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[16]
1359 #define SWIGTYPE_p_void swig_types[17]
1360 #define SWIGTYPE_p_int swig_types[18]
1361 #define SWIGTYPE_p_wxSize swig_types[19]
1362 #define SWIGTYPE_p_wxClipboard swig_types[20]
1363 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1364 #define SWIGTYPE_p_wxDC swig_types[22]
1365 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
1366 #define SWIGTYPE_p_wxIcon swig_types[24]
1367 #define SWIGTYPE_p_wxLogStderr swig_types[25]
1368 #define SWIGTYPE_p_wxLogTextCtrl swig_types[26]
1369 #define SWIGTYPE_p_wxTextCtrl swig_types[27]
1370 #define SWIGTYPE_p_wxBusyCursor swig_types[28]
1371 #define SWIGTYPE_p_wxBitmapDataObject swig_types[29]
1372 #define SWIGTYPE_p_wxTextDataObject swig_types[30]
1373 #define SWIGTYPE_p_wxDataObject swig_types[31]
1374 #define SWIGTYPE_p_wxPyTextDataObject swig_types[32]
1375 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[33]
1376 #define SWIGTYPE_p_wxFileDataObject swig_types[34]
1377 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
1378 #define SWIGTYPE_p_wxURLDataObject swig_types[36]
1379 #define SWIGTYPE_p_wxMetafileDataObject swig_types[37]
1380 #define SWIGTYPE_p_wxSound swig_types[38]
1381 #define SWIGTYPE_p_wxTimerRunner swig_types[39]
1382 #define SWIGTYPE_p_wxLogWindow swig_types[40]
1383 #define SWIGTYPE_p_wxTimeSpan swig_types[41]
1384 #define SWIGTYPE_p_wxArrayString swig_types[42]
1385 #define SWIGTYPE_p_wxWindowDisabler swig_types[43]
1386 #define SWIGTYPE_p_form_ops_t swig_types[44]
1387 #define SWIGTYPE_p_wxToolTip swig_types[45]
1388 #define SWIGTYPE_p_wxDataObjectComposite swig_types[46]
1389 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1390 #define SWIGTYPE_p_wxFileConfig swig_types[48]
1391 #define SWIGTYPE_p_wxVideoMode swig_types[49]
1392 #define SWIGTYPE_p_wxDataObjectSimple swig_types[50]
1393 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[51]
1394 #define SWIGTYPE_p_wxDuplexMode swig_types[52]
1395 #define SWIGTYPE_p_wxEvtHandler swig_types[53]
1396 #define SWIGTYPE_p_wxRect swig_types[54]
1397 #define SWIGTYPE_p_char swig_types[55]
1398 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[56]
1399 #define SWIGTYPE_p_wxStandardPaths swig_types[57]
1400 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
1401 #define SWIGTYPE_p_wxFrame swig_types[59]
1402 #define SWIGTYPE_p_wxTimer swig_types[60]
1403 #define SWIGTYPE_p_wxPaperSize swig_types[61]
1404 #define SWIGTYPE_p_wxMimeTypesManager swig_types[62]
1405 #define SWIGTYPE_p_wxPyArtProvider swig_types[63]
1406 #define SWIGTYPE_p_wxPyTipProvider swig_types[64]
1407 #define SWIGTYPE_p_wxTipProvider swig_types[65]
1408 #define SWIGTYPE_p_wxJoystick swig_types[66]
1409 #define SWIGTYPE_p_wxSystemOptions swig_types[67]
1410 #define SWIGTYPE_p_wxPoint swig_types[68]
1411 #define SWIGTYPE_p_wxJoystickEvent swig_types[69]
1412 #define SWIGTYPE_p_wxCursor swig_types[70]
1413 #define SWIGTYPE_p_wxObject swig_types[71]
1414 #define SWIGTYPE_p_wxOutputStream swig_types[72]
1415 #define SWIGTYPE_p_wxDateTime swig_types[73]
1416 #define SWIGTYPE_p_wxPyDropSource swig_types[74]
1417 #define SWIGTYPE_p_unsigned_long swig_types[75]
1418 #define SWIGTYPE_p_wxKillError swig_types[76]
1419 #define SWIGTYPE_p_wxWindow swig_types[77]
1420 #define SWIGTYPE_p_wxString swig_types[78]
1421 #define SWIGTYPE_p_wxPyProcess swig_types[79]
1422 #define SWIGTYPE_p_wxBitmap swig_types[80]
1423 #define SWIGTYPE_unsigned_int swig_types[81]
1424 #define SWIGTYPE_p_unsigned_int swig_types[82]
1425 #define SWIGTYPE_p_wxConfig swig_types[83]
1426 #define SWIGTYPE_p_unsigned_char swig_types[84]
1427 #define SWIGTYPE_p_wxChar swig_types[85]
1428 #define SWIGTYPE_p_wxBusyInfo swig_types[86]
1429 #define SWIGTYPE_p_wxPyDropTarget swig_types[87]
1430 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[88]
1431 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[89]
1432 #define SWIGTYPE_p_wxProcessEvent swig_types[90]
1433 #define SWIGTYPE_p_wxPyLog swig_types[91]
1434 #define SWIGTYPE_p_wxLogNull swig_types[92]
1435 #define SWIGTYPE_p_wxColour swig_types[93]
1436 #define SWIGTYPE_p_wxPyTimer swig_types[94]
1437 #define SWIGTYPE_p_wxConfigPathChanger swig_types[95]
1438 #define SWIGTYPE_p_wxDateSpan swig_types[96]
1439 static swig_type_info *swig_types[98];
1440
1441 /* -------- TYPES TABLE (END) -------- */
1442
1443
1444 /*-----------------------------------------------
1445 @(target):= _misc_.so
1446 ------------------------------------------------*/
1447 #define SWIG_init init_misc_
1448
1449 #define SWIG_name "_misc_"
1450
1451 #include "wx/wxPython/wxPython.h"
1452 #include "wx/wxPython/pyclasses.h"
1453 #include "wx/wxPython/pyistream.h"
1454
1455 static const wxString wxPyEmptyString(wxEmptyString);
1456
1457
1458
1459 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1460 #define SWIG_From_int PyInt_FromLong
1461 /*@@*/
1462
1463
1464 #include <limits.h>
1465
1466
1467 SWIGINTERN int
1468 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1469 const char *errmsg)
1470 {
1471 if (value < min_value) {
1472 if (errmsg) {
1473 PyErr_Format(PyExc_OverflowError,
1474 "value %ld is less than '%s' minimum %ld",
1475 value, errmsg, min_value);
1476 }
1477 return 0;
1478 } else if (value > max_value) {
1479 if (errmsg) {
1480 PyErr_Format(PyExc_OverflowError,
1481 "value %ld is greater than '%s' maximum %ld",
1482 value, errmsg, max_value);
1483 }
1484 return 0;
1485 }
1486 return 1;
1487 }
1488
1489
1490 SWIGINTERN int
1491 SWIG_AsVal_long(PyObject* obj, long* val)
1492 {
1493 if (PyNumber_Check(obj)) {
1494 if (val) *val = PyInt_AsLong(obj);
1495 return 1;
1496 }
1497 else {
1498 SWIG_type_error("number", obj);
1499 }
1500 return 0;
1501 }
1502
1503
1504 #if INT_MAX != LONG_MAX
1505 SWIGINTERN int
1506 SWIG_AsVal_int(PyObject *obj, int *val)
1507 {
1508 const char* errmsg = val ? "int" : (char*)0;
1509 long v;
1510 if (SWIG_AsVal_long(obj, &v)) {
1511 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1512 if (val) *val = (int)(v);
1513 return 1;
1514 } else {
1515 return 0;
1516 }
1517 } else {
1518 PyErr_Clear();
1519 }
1520 if (val) {
1521 SWIG_type_error(errmsg, obj);
1522 }
1523 return 0;
1524 }
1525 #else
1526 SWIGINTERNSHORT int
1527 SWIG_AsVal_int(PyObject *obj, int *val)
1528 {
1529 return SWIG_AsVal_long(obj,(long*)val);
1530 }
1531 #endif
1532
1533
1534 SWIGINTERNSHORT int
1535 SWIG_As_int(PyObject* obj)
1536 {
1537 int v;
1538 if (!SWIG_AsVal_int(obj, &v)) {
1539 /*
1540 this is needed to make valgrind/purify happier.
1541 */
1542 memset((void*)&v, 0, sizeof(int));
1543 }
1544 return v;
1545 }
1546
1547
1548 SWIGINTERNSHORT int
1549 SWIG_Check_int(PyObject* obj)
1550 {
1551 return SWIG_AsVal_int(obj, (int*)0);
1552 }
1553
1554 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1555
1556 #include <wx/stockitem.h>
1557
1558 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1559 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1560 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1561
1562 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1563 #define SWIG_From_long PyInt_FromLong
1564 /*@@*/
1565
1566
1567 SWIGINTERNSHORT long
1568 SWIG_As_long(PyObject* obj)
1569 {
1570 long v;
1571 if (!SWIG_AsVal_long(obj, &v)) {
1572 /*
1573 this is needed to make valgrind/purify happier.
1574 */
1575 memset((void*)&v, 0, sizeof(long));
1576 }
1577 return v;
1578 }
1579
1580
1581 SWIGINTERNSHORT int
1582 SWIG_Check_long(PyObject* obj)
1583 {
1584 return SWIG_AsVal_long(obj, (long*)0);
1585 }
1586
1587
1588 SWIGINTERN int
1589 SWIG_AsVal_bool(PyObject *obj, bool *val)
1590 {
1591 if (obj == Py_True) {
1592 if (val) *val = true;
1593 return 1;
1594 }
1595 if (obj == Py_False) {
1596 if (val) *val = false;
1597 return 1;
1598 }
1599 int res = 0;
1600 if (SWIG_AsVal_int(obj, &res)) {
1601 if (val) *val = res ? true : false;
1602 return 1;
1603 } else {
1604 PyErr_Clear();
1605 }
1606 if (val) {
1607 SWIG_type_error("bool", obj);
1608 }
1609 return 0;
1610 }
1611
1612
1613 SWIGINTERNSHORT bool
1614 SWIG_As_bool(PyObject* obj)
1615 {
1616 bool v;
1617 if (!SWIG_AsVal_bool(obj, &v)) {
1618 /*
1619 this is needed to make valgrind/purify happier.
1620 */
1621 memset((void*)&v, 0, sizeof(bool));
1622 }
1623 return v;
1624 }
1625
1626
1627 SWIGINTERNSHORT int
1628 SWIG_Check_bool(PyObject* obj)
1629 {
1630 return SWIG_AsVal_bool(obj, (bool*)0);
1631 }
1632
1633
1634 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1635 PyObject* o2;
1636 PyObject* o3;
1637
1638 if (!target) {
1639 target = o;
1640 } else if (target == Py_None) {
1641 Py_DECREF(Py_None);
1642 target = o;
1643 } else {
1644 if (!PyTuple_Check(target)) {
1645 o2 = target;
1646 target = PyTuple_New(1);
1647 PyTuple_SetItem(target, 0, o2);
1648 }
1649 o3 = PyTuple_New(1);
1650 PyTuple_SetItem(o3, 0, o);
1651
1652 o2 = target;
1653 target = PySequence_Concat(o2, o3);
1654 Py_DECREF(o2);
1655 Py_DECREF(o3);
1656 }
1657 return target;
1658 }
1659
1660
1661
1662 long wxGetFreeMemory()
1663 { wxPyRaiseNotImplemented(); return 0; }
1664
1665
1666 SWIGINTERN int
1667 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1668 {
1669 long v = 0;
1670 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1671 SWIG_type_error("unsigned number", obj);
1672 }
1673 else if (val)
1674 *val = (unsigned long)v;
1675 return 1;
1676 }
1677
1678
1679 SWIGINTERNSHORT unsigned long
1680 SWIG_As_unsigned_SS_long(PyObject* obj)
1681 {
1682 unsigned long v;
1683 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1684 /*
1685 this is needed to make valgrind/purify happier.
1686 */
1687 memset((void*)&v, 0, sizeof(unsigned long));
1688 }
1689 return v;
1690 }
1691
1692
1693 SWIGINTERNSHORT int
1694 SWIG_Check_unsigned_SS_long(PyObject* obj)
1695 {
1696 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1697 }
1698
1699
1700 SWIGINTERNSHORT PyObject*
1701 SWIG_From_unsigned_SS_long(unsigned long value)
1702 {
1703 return (value > LONG_MAX) ?
1704 PyLong_FromUnsignedLong(value)
1705 : PyInt_FromLong((long)(value));
1706 }
1707
1708
1709 void* wxGetXDisplay()
1710 {
1711 #ifdef __WXGTK__
1712 return wxGetDisplay();
1713 #else
1714 return NULL;
1715 #endif
1716 }
1717
1718
1719 void wxWakeUpMainThread() {}
1720
1721
1722 bool wxThread_IsMain() {
1723 #ifdef WXP_WITH_THREAD
1724 return wxThread::IsMain();
1725 #else
1726 return true;
1727 #endif
1728 }
1729
1730 static void wxCaret_Destroy(wxCaret *self){
1731 delete self;
1732 }
1733
1734 #include <wx/snglinst.h>
1735
1736
1737 #ifdef __WXMSW__
1738 #include <wx/msw/private.h>
1739 #include <wx/dynload.h>
1740 #endif
1741
1742
1743
1744 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1745 #if 0
1746 , int method
1747 #endif
1748 )
1749 {
1750 #ifdef __WXMSW__
1751 #if 0
1752 switch (method)
1753 {
1754 case 1:
1755 // This one only partially works. Appears to be an undocumented
1756 // "standard" convention that not all widgets adhear to. For
1757 // example, for some widgets backgrounds or non-client areas may
1758 // not be painted.
1759 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1760 break;
1761
1762 case 2:
1763 #endif
1764 // This one works much better, nearly all widgets and their
1765 // children are captured correctly[**]. Prior to the big
1766 // background erase changes that Vadim did in 2004-2005 this
1767 // method failed badly on XP with Themes activated, most native
1768 // widgets draw only partially, if at all. Without themes it
1769 // worked just like on Win2k. After those changes this method
1770 // works very well.
1771 //
1772 // ** For example the radio buttons in a wxRadioBox are not its
1773 // children by default, but you can capture it via the panel
1774 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1775 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1776 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1777 PRF_ERASEBKGND | PRF_OWNED );
1778 return true;
1779 #if 0
1780 break;
1781
1782 case 3:
1783 // This one is only defined in the latest SDK and is only
1784 // available on XP. MSDN says it is similar to sending WM_PRINT
1785 // so I expect that it will work similar to the above. Since it
1786 // is avaialble only on XP, it can't be compiled like this and
1787 // will have to be loaded dynamically.
1788 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1789
1790 // fall through
1791
1792 case 4:
1793 // Use PrintWindow if available, or fallback to WM_PRINT
1794 // otherwise. Unfortunately using PrintWindow is even worse than
1795 // WM_PRINT. For most native widgets nothing is drawn to the dc
1796 // at all, with or without Themes.
1797 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1798 static bool s_triedToLoad = false;
1799 static PrintWindow_t pfnPrintWindow = NULL;
1800 if ( !s_triedToLoad )
1801 {
1802
1803 s_triedToLoad = true;
1804 wxDynamicLibrary dllUser32(_T("user32.dll"));
1805 if ( dllUser32.IsLoaded() )
1806 {
1807 wxLogNull nolog; // Don't report errors here
1808 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1809 }
1810 }
1811 if (pfnPrintWindow)
1812 {
1813 //printf("Using PrintWindow\n");
1814 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1815 }
1816 else
1817 {
1818 //printf("Using WM_PRINT\n");
1819 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1820 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1821 PRF_ERASEBKGND | PRF_OWNED );
1822 }
1823 }
1824 #endif // 0
1825 #else
1826 return false;
1827 #endif // __WXMSW__
1828 }
1829
1830
1831
1832 #include <wx/tipdlg.h>
1833
1834
1835 class wxPyTipProvider : public wxTipProvider {
1836 public:
1837 wxPyTipProvider(size_t currentTip)
1838 : wxTipProvider(currentTip) {}
1839
1840 DEC_PYCALLBACK_STRING__pure(GetTip);
1841 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1842 PYPRIVATE;
1843 };
1844
1845 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1846 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1847
1848
1849 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1850
1851 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1852
1853 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1854 : wxTimer(owner, id)
1855 {
1856 if (owner == NULL) SetOwner(this);
1857 }
1858
1859
1860 void wxPyTimer::Notify() {
1861 bool found;
1862 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1863 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1864 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1865 wxPyEndBlockThreads(blocked);
1866 if (! found)
1867 wxTimer::Notify();
1868 }
1869 void wxPyTimer::base_Notify() {
1870 wxTimer::Notify();
1871 }
1872
1873
1874
1875 SWIGINTERN PyObject *
1876 SWIG_FromCharPtr(const char* cptr)
1877 {
1878 if (cptr) {
1879 size_t size = strlen(cptr);
1880 if (size > INT_MAX) {
1881 return SWIG_NewPointerObj((char*)(cptr),
1882 SWIG_TypeQuery("char *"), 0);
1883 } else {
1884 if (size != 0) {
1885 return PyString_FromStringAndSize(cptr, size);
1886 } else {
1887 return PyString_FromString(cptr);
1888 }
1889 }
1890 }
1891 Py_INCREF(Py_None);
1892 return Py_None;
1893 }
1894
1895
1896 SWIGINTERNSHORT int
1897 SWIG_CheckUnsignedLongInRange(unsigned long value,
1898 unsigned long max_value,
1899 const char *errmsg)
1900 {
1901 if (value > max_value) {
1902 if (errmsg) {
1903 PyErr_Format(PyExc_OverflowError,
1904 "value %lu is greater than '%s' minimum %lu",
1905 value, errmsg, max_value);
1906 }
1907 return 0;
1908 }
1909 return 1;
1910 }
1911
1912
1913 #if UINT_MAX != ULONG_MAX
1914 SWIGINTERN int
1915 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1916 {
1917 const char* errmsg = val ? "unsigned int" : (char*)0;
1918 unsigned long v;
1919 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1920 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1921 if (val) *val = (unsigned int)(v);
1922 return 1;
1923 }
1924 } else {
1925 PyErr_Clear();
1926 }
1927 if (val) {
1928 SWIG_type_error(errmsg, obj);
1929 }
1930 return 0;
1931 }
1932 #else
1933 SWIGINTERNSHORT unsigned int
1934 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1935 {
1936 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1937 }
1938 #endif
1939
1940
1941 SWIGINTERNSHORT unsigned int
1942 SWIG_As_unsigned_SS_int(PyObject* obj)
1943 {
1944 unsigned int v;
1945 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1946 /*
1947 this is needed to make valgrind/purify happier.
1948 */
1949 memset((void*)&v, 0, sizeof(unsigned int));
1950 }
1951 return v;
1952 }
1953
1954
1955 SWIGINTERNSHORT int
1956 SWIG_Check_unsigned_SS_int(PyObject* obj)
1957 {
1958 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1959 }
1960
1961 static wxString Log_TimeStamp(){
1962 wxString msg;
1963 wxLog::TimeStamp(&msg);
1964 return msg;
1965 }
1966 static void wxLog_Destroy(wxLog *self){ delete self; }
1967 // Make somce wrappers that double any % signs so they are 'escaped'
1968 void wxPyLogFatalError(const wxString& msg)
1969 {
1970 wxString m(msg);
1971 m.Replace(wxT("%"), wxT("%%"));
1972 wxLogFatalError(m);
1973 }
1974
1975 void wxPyLogError(const wxString& msg)
1976 {
1977 wxString m(msg);
1978 m.Replace(wxT("%"), wxT("%%"));
1979 wxLogError(m);
1980 }
1981
1982 void wxPyLogWarning(const wxString& msg)
1983 {
1984 wxString m(msg);
1985 m.Replace(wxT("%"), wxT("%%"));
1986 wxLogWarning(m);
1987 }
1988
1989 void wxPyLogMessage(const wxString& msg)
1990 {
1991 wxString m(msg);
1992 m.Replace(wxT("%"), wxT("%%"));
1993 wxLogMessage(m);
1994 }
1995
1996 void wxPyLogInfo(const wxString& msg)
1997 {
1998 wxString m(msg);
1999 m.Replace(wxT("%"), wxT("%%"));
2000 wxLogInfo(m);
2001 }
2002
2003 void wxPyLogDebug(const wxString& msg)
2004 {
2005 wxString m(msg);
2006 m.Replace(wxT("%"), wxT("%%"));
2007 wxLogDebug(m);
2008 }
2009
2010 void wxPyLogVerbose(const wxString& msg)
2011 {
2012 wxString m(msg);
2013 m.Replace(wxT("%"), wxT("%%"));
2014 wxLogVerbose(m);
2015 }
2016
2017 void wxPyLogStatus(const wxString& msg)
2018 {
2019 wxString m(msg);
2020 m.Replace(wxT("%"), wxT("%%"));
2021 wxLogStatus(m);
2022 }
2023
2024 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2025 {
2026 wxString m(msg);
2027 m.Replace(wxT("%"), wxT("%%"));
2028 wxLogStatus(pFrame, m);
2029 }
2030
2031 void wxPyLogSysError(const wxString& msg)
2032 {
2033 wxString m(msg);
2034 m.Replace(wxT("%"), wxT("%%"));
2035 wxLogSysError(m);
2036 }
2037
2038 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2039 {
2040 wxString m(msg);
2041 m.Replace(wxT("%"), wxT("%%"));
2042 wxLogGeneric(level, m);
2043 }
2044
2045 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2046 {
2047 wxString m(msg);
2048 m.Replace(wxT("%"), wxT("%%"));
2049 wxLogTrace(mask, m);
2050 }
2051
2052 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2053 {
2054 wxString m(msg);
2055 m.Replace(wxT("%"), wxT("%%"));
2056 wxLogTrace(mask, m);
2057 }
2058
2059
2060
2061 // A wxLog class that can be derived from in wxPython
2062 class wxPyLog : public wxLog {
2063 public:
2064 wxPyLog() : wxLog() {}
2065
2066 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2067 bool found;
2068 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2069 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2070 PyObject* s = wx2PyString(szString);
2071 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2072 Py_DECREF(s);
2073 }
2074 wxPyEndBlockThreads(blocked);
2075 if (! found)
2076 wxLog::DoLog(level, szString, t);
2077 }
2078
2079 virtual void DoLogString(const wxChar *szString, time_t t) {
2080 bool found;
2081 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2082 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2083 PyObject* s = wx2PyString(szString);
2084 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2085 Py_DECREF(s);
2086 }
2087 wxPyEndBlockThreads(blocked);
2088 if (! found)
2089 wxLog::DoLogString(szString, t);
2090 }
2091
2092 PYPRIVATE;
2093 };
2094
2095
2096
2097
2098 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2099
2100
2101 #include <wx/joystick.h>
2102
2103
2104 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2105 // A C++ stub class for wxJoystick for platforms that don't have it.
2106 class wxJoystick : public wxObject {
2107 public:
2108 wxJoystick(int joystick = wxJOYSTICK1) {
2109 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2110 PyErr_SetString(PyExc_NotImplementedError,
2111 "wxJoystick is not available on this platform.");
2112 wxPyEndBlockThreads(blocked);
2113 }
2114 wxPoint GetPosition() { return wxPoint(-1,-1); }
2115 int GetZPosition() { return -1; }
2116 int GetButtonState() { return -1; }
2117 int GetPOVPosition() { return -1; }
2118 int GetPOVCTSPosition() { return -1; }
2119 int GetRudderPosition() { return -1; }
2120 int GetUPosition() { return -1; }
2121 int GetVPosition() { return -1; }
2122 int GetMovementThreshold() { return -1; }
2123 void SetMovementThreshold(int threshold) {}
2124
2125 bool IsOk(void) { return false; }
2126 int GetNumberJoysticks() { return -1; }
2127 int GetManufacturerId() { return -1; }
2128 int GetProductId() { return -1; }
2129 wxString GetProductName() { return wxEmptyString; }
2130 int GetXMin() { return -1; }
2131 int GetYMin() { return -1; }
2132 int GetZMin() { return -1; }
2133 int GetXMax() { return -1; }
2134 int GetYMax() { return -1; }
2135 int GetZMax() { return -1; }
2136 int GetNumberButtons() { return -1; }
2137 int GetNumberAxes() { return -1; }
2138 int GetMaxButtons() { return -1; }
2139 int GetMaxAxes() { return -1; }
2140 int GetPollingMin() { return -1; }
2141 int GetPollingMax() { return -1; }
2142 int GetRudderMin() { return -1; }
2143 int GetRudderMax() { return -1; }
2144 int GetUMin() { return -1; }
2145 int GetUMax() { return -1; }
2146 int GetVMin() { return -1; }
2147 int GetVMax() { return -1; }
2148
2149 bool HasRudder() { return false; }
2150 bool HasZ() { return false; }
2151 bool HasU() { return false; }
2152 bool HasV() { return false; }
2153 bool HasPOV() { return false; }
2154 bool HasPOV4Dir() { return false; }
2155 bool HasPOVCTS() { return false; }
2156
2157 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2158 bool ReleaseCapture() { return false; }
2159 };
2160 #endif
2161
2162
2163 #include <wx/sound.h>
2164
2165
2166 #if !wxUSE_SOUND
2167 // A C++ stub class for wxWave for platforms that don't have it.
2168 class wxSound : public wxObject
2169 {
2170 public:
2171 wxSound() {
2172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2173 PyErr_SetString(PyExc_NotImplementedError,
2174 "wxSound is not available on this platform.");
2175 wxPyEndBlockThreads(blocked);
2176 }
2177 wxSound(const wxString&/*, bool*/) {
2178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2179 PyErr_SetString(PyExc_NotImplementedError,
2180 "wxSound is not available on this platform.");
2181 wxPyEndBlockThreads(blocked);
2182 }
2183 wxSound(int, const wxByte*) {
2184 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2185 PyErr_SetString(PyExc_NotImplementedError,
2186 "wxSound is not available on this platform.");
2187 wxPyEndBlockThreads(blocked);
2188 }
2189
2190 ~wxSound() {};
2191
2192 bool Create(const wxString&/*, bool*/) { return false; }
2193 bool Create(int, const wxByte*) { return false; };
2194 bool IsOk() { return false; };
2195 bool Play(unsigned) const { return false; }
2196 static bool Play(const wxString&, unsigned) { return false; }
2197 static void Stop() {}
2198 };
2199
2200 #endif
2201
2202 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2203 if (fileName.Length() == 0)
2204 return new wxSound;
2205 else
2206 return new wxSound(fileName);
2207 }
2208 static wxSound *new_wxSound(PyObject *data){
2209 unsigned char* buffer; int size;
2210 wxSound *sound = NULL;
2211
2212 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2213 if (!PyArg_Parse(data, "t#", &buffer, &size))
2214 goto done;
2215 sound = new wxSound(size, buffer);
2216 done:
2217 wxPyEndBlockThreads(blocked);
2218 return sound;
2219 }
2220 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2221 #ifndef __WXMAC__
2222 unsigned char* buffer;
2223 int size;
2224 bool rv = false;
2225
2226 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2227 if (!PyArg_Parse(data, "t#", &buffer, &size))
2228 goto done;
2229 rv = self->Create(size, buffer);
2230 done:
2231 wxPyEndBlockThreads(blocked);
2232 return rv;
2233 #else
2234 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2235 PyErr_SetString(PyExc_NotImplementedError,
2236 "Create from data is not available on this platform.");
2237 wxPyEndBlockThreads(blocked);
2238 return false;
2239 #endif
2240 }
2241
2242 #include <wx/mimetype.h>
2243
2244 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2245 wxString str;
2246 if (self->GetMimeType(&str))
2247 return wx2PyString(str);
2248 else
2249 RETURN_NONE();
2250 }
2251 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2252 wxArrayString arr;
2253 if (self->GetMimeTypes(arr))
2254 return wxArrayString2PyList_helper(arr);
2255 else
2256 RETURN_NONE();
2257 }
2258 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2259 wxArrayString arr;
2260 if (self->GetExtensions(arr))
2261 return wxArrayString2PyList_helper(arr);
2262 else
2263 RETURN_NONE();
2264 }
2265 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2266 wxIconLocation loc;
2267 if (self->GetIcon(&loc))
2268 return new wxIcon(loc);
2269 else
2270 return NULL;
2271 }
2272 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2273 wxIconLocation loc;
2274 if (self->GetIcon(&loc)) {
2275 wxString iconFile = loc.GetFileName();
2276 int iconIndex = -1;
2277
2278
2279
2280 // Make a tuple and put the values in it
2281 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2282 PyObject* tuple = PyTuple_New(3);
2283 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2284 wxT("wxIcon"), true));
2285 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2286 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2287 wxPyEndBlockThreads(blocked);
2288 return tuple;
2289 }
2290 else
2291 RETURN_NONE();
2292 }
2293 static PyObject *wxFileType_GetDescription(wxFileType *self){
2294 wxString str;
2295 if (self->GetDescription(&str))
2296 return wx2PyString(str);
2297 else
2298 RETURN_NONE();
2299 }
2300 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2301 wxString str;
2302 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2303 return wx2PyString(str);
2304 else
2305 RETURN_NONE();
2306 }
2307 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2308 wxString str;
2309 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2310 return wx2PyString(str);
2311 else
2312 RETURN_NONE();
2313 }
2314 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2315 wxArrayString verbs;
2316 wxArrayString commands;
2317 if (self->GetAllCommands(&verbs, &commands,
2318 wxFileType::MessageParameters(filename, mimetype))) {
2319 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2320 PyObject* tuple = PyTuple_New(2);
2321 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2322 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2323 wxPyEndBlockThreads(blocked);
2324 return tuple;
2325 }
2326 else
2327 RETURN_NONE();
2328 }
2329 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2330 return wxFileType::ExpandCommand(command,
2331 wxFileType::MessageParameters(filename, mimetype));
2332 }
2333 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2334 wxArrayString arr;
2335 self->EnumAllFileTypes(arr);
2336 return wxArrayString2PyList_helper(arr);
2337 }
2338
2339 #include <wx/artprov.h>
2340
2341 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2342 static const wxString wxPyART_MENU(wxART_MENU);
2343 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2344 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2345 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2346 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2347 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2348 static const wxString wxPyART_OTHER(wxART_OTHER);
2349 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2350 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2351 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2352 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2353 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2354 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2355 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2356 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2357 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2358 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2359 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2360 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2361 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2362 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2363 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2364 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2365 static const wxString wxPyART_PRINT(wxART_PRINT);
2366 static const wxString wxPyART_HELP(wxART_HELP);
2367 static const wxString wxPyART_TIP(wxART_TIP);
2368 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2369 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2370 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2371 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2372 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2373 static const wxString wxPyART_CDROM(wxART_CDROM);
2374 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2375 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2376 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2377 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2378 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2379 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2380 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2381 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2382 static const wxString wxPyART_ERROR(wxART_ERROR);
2383 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2384 static const wxString wxPyART_WARNING(wxART_WARNING);
2385 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2386 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2387 static const wxString wxPyART_COPY(wxART_COPY);
2388 static const wxString wxPyART_CUT(wxART_CUT);
2389 static const wxString wxPyART_PASTE(wxART_PASTE);
2390 static const wxString wxPyART_DELETE(wxART_DELETE);
2391 static const wxString wxPyART_NEW(wxART_NEW);
2392 static const wxString wxPyART_UNDO(wxART_UNDO);
2393 static const wxString wxPyART_REDO(wxART_REDO);
2394 static const wxString wxPyART_QUIT(wxART_QUIT);
2395 static const wxString wxPyART_FIND(wxART_FIND);
2396 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2397 // Python aware wxArtProvider
2398 class wxPyArtProvider : public wxArtProvider {
2399 public:
2400
2401 virtual wxBitmap CreateBitmap(const wxArtID& id,
2402 const wxArtClient& client,
2403 const wxSize& size) {
2404 wxBitmap rval = wxNullBitmap;
2405 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2406 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2407 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2408 PyObject* ro;
2409 wxBitmap* ptr;
2410 PyObject* s1, *s2;
2411 s1 = wx2PyString(id);
2412 s2 = wx2PyString(client);
2413 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2414 Py_DECREF(so);
2415 Py_DECREF(s1);
2416 Py_DECREF(s2);
2417 if (ro) {
2418 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2419 rval = *ptr;
2420 Py_DECREF(ro);
2421 }
2422 }
2423 wxPyEndBlockThreads(blocked);
2424 return rval;
2425 }
2426
2427 PYPRIVATE;
2428 };
2429
2430 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2431
2432
2433
2434 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2435 PyObject* ret = PyTuple_New(3);
2436 if (ret) {
2437 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2438 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2439 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2440 }
2441 return ret;
2442 }
2443
2444 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2445 bool cont;
2446 long index = 0;
2447 wxString value;
2448
2449 cont = self->GetFirstGroup(value, index);
2450 return __EnumerationHelper(cont, value, index);
2451 }
2452 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2453 bool cont;
2454 wxString value;
2455
2456 cont = self->GetNextGroup(value, index);
2457 return __EnumerationHelper(cont, value, index);
2458 }
2459 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2460 bool cont;
2461 long index = 0;
2462 wxString value;
2463
2464 cont = self->GetFirstEntry(value, index);
2465 return __EnumerationHelper(cont, value, index);
2466 }
2467 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2468 bool cont;
2469 wxString value;
2470
2471 cont = self->GetNextEntry(value, index);
2472 return __EnumerationHelper(cont, value, index);
2473 }
2474 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2475 long rv;
2476 self->Read(key, &rv, defaultVal);
2477 return rv;
2478 }
2479
2480 SWIGINTERN int
2481 SWIG_AsVal_double(PyObject *obj, double* val)
2482 {
2483 if (PyNumber_Check(obj)) {
2484 if (val) *val = PyFloat_AsDouble(obj);
2485 return 1;
2486 }
2487 else {
2488 SWIG_type_error("number", obj);
2489 }
2490 return 0;
2491 }
2492
2493
2494 SWIGINTERNSHORT double
2495 SWIG_As_double(PyObject* obj)
2496 {
2497 double v;
2498 if (!SWIG_AsVal_double(obj, &v)) {
2499 /*
2500 this is needed to make valgrind/purify happier.
2501 */
2502 memset((void*)&v, 0, sizeof(double));
2503 }
2504 return v;
2505 }
2506
2507
2508 SWIGINTERNSHORT int
2509 SWIG_Check_double(PyObject* obj)
2510 {
2511 return SWIG_AsVal_double(obj, (double*)0);
2512 }
2513
2514 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2515 double rv;
2516 self->Read(key, &rv, defaultVal);
2517 return rv;
2518 }
2519
2520 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2521 #define SWIG_From_double PyFloat_FromDouble
2522 /*@@*/
2523
2524 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2525 bool rv;
2526 self->Read(key, &rv, defaultVal);
2527 return rv;
2528 }
2529
2530 #include <wx/datetime.h>
2531
2532 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2533 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2534
2535 #define LOCAL_TZ wxDateTime::Local
2536
2537 static PyObject *DateTime_GetAmPmStrings(){
2538 wxString am;
2539 wxString pm;
2540 wxDateTime::GetAmPmStrings(&am, &pm);
2541 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2542 PyObject* tup = PyTuple_New(2);
2543 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2544 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2545 wxPyEndBlockThreads(blocked);
2546 return tup;
2547 }
2548
2549 #if UINT_MAX < LONG_MAX
2550 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2551 #define SWIG_From_unsigned_SS_int SWIG_From_long
2552 /*@@*/
2553 #else
2554 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2555 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2556 /*@@*/
2557 #endif
2558
2559 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2560 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2561 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2562 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2563 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2564 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2565 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2566 return (*self < *other);
2567 }
2568 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2569 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2570 return (*self <= *other);
2571 }
2572 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2573 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2574 return (*self > *other);
2575 }
2576 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2577 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2578 return (*self >= *other);
2579 }
2580 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2581 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2582 return (*self == *other);
2583 }
2584 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2585 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2586 return (*self != *other);
2587 }
2588 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2589 const wxChar* rv;
2590 const wxChar* _date = date;
2591 rv = self->ParseRfc822Date(_date);
2592 if (rv == NULL) return -1;
2593 return rv - _date;
2594 }
2595 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2596 const wxChar* rv;
2597 const wxChar* _date = date;
2598 rv = self->ParseFormat(_date, format, dateDef);
2599 if (rv == NULL) return -1;
2600 return rv - _date;
2601 }
2602 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2603 const wxChar* rv;
2604 const wxChar* _datetime = datetime;
2605 rv = self->ParseDateTime(_datetime);
2606 if (rv == NULL) return -1;
2607 return rv - _datetime;
2608 }
2609 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2610 const wxChar* rv;
2611 const wxChar* _date = date;
2612 rv = self->ParseDate(_date);
2613 if (rv == NULL) return -1;
2614 return rv - _date;
2615 }
2616 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2617 const wxChar* rv;
2618 const wxChar* _time = time;
2619 rv = self->ParseTime(_time);
2620 if (rv == NULL) return -1;
2621 return rv - _time;
2622 }
2623 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2624 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2625 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2626 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2627 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2628 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2629 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2630 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2631 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2632 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2633 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2634 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2635 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2636 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2637 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2638 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2639
2640 #include <wx/dataobj.h>
2641
2642 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2643 size_t count = self->GetFormatCount(dir);
2644 wxDataFormat* formats = new wxDataFormat[count];
2645 self->GetAllFormats(formats, dir);
2646
2647 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2648 PyObject* list = PyList_New(count);
2649 for (size_t i=0; i<count; i++) {
2650 wxDataFormat* format = new wxDataFormat(formats[i]);
2651 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2652 PyList_Append(list, obj);
2653 Py_DECREF(obj);
2654 }
2655 wxPyEndBlockThreads(blocked);
2656 delete [] formats;
2657 return list;
2658 }
2659 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2660 PyObject* rval = NULL;
2661 size_t size = self->GetDataSize(format);
2662 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2663 if (size) {
2664 char* buf = new char[size];
2665 if (self->GetDataHere(format, buf))
2666 rval = PyString_FromStringAndSize(buf, size);
2667 delete [] buf;
2668 }
2669 if (! rval) {
2670 rval = Py_None;
2671 Py_INCREF(rval);
2672 }
2673 wxPyEndBlockThreads(blocked);
2674 return rval;
2675 }
2676 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2677 bool rval;
2678 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2679 if (PyString_Check(data)) {
2680 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2681 }
2682 else {
2683 // raise a TypeError if not a string
2684 PyErr_SetString(PyExc_TypeError, "String expected.");
2685 rval = false;
2686 }
2687 wxPyEndBlockThreads(blocked);
2688 return rval;
2689 }
2690 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2691 PyObject* rval = NULL;
2692 size_t size = self->GetDataSize();
2693 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2694 if (size) {
2695 char* buf = new char[size];
2696 if (self->GetDataHere(buf))
2697 rval = PyString_FromStringAndSize(buf, size);
2698 delete [] buf;
2699 }
2700 if (! rval) {
2701 rval = Py_None;
2702 Py_INCREF(rval);
2703 }
2704 wxPyEndBlockThreads(blocked);
2705 return rval;
2706 }
2707 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2708 bool rval;
2709 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2710 if (PyString_Check(data)) {
2711 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2712 }
2713 else {
2714 // raise a TypeError if not a string
2715 PyErr_SetString(PyExc_TypeError, "String expected.");
2716 rval = false;
2717 }
2718 wxPyEndBlockThreads(blocked);
2719 return rval;
2720 }
2721 // Create a new class for wxPython to use
2722 class wxPyDataObjectSimple : public wxDataObjectSimple {
2723 public:
2724 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2725 : wxDataObjectSimple(format) {}
2726
2727 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2728 bool GetDataHere(void *buf) const;
2729 bool SetData(size_t len, const void *buf) const;
2730 PYPRIVATE;
2731 };
2732
2733 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2734
2735 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2736 // We need to get the data for this object and write it to buf. I think
2737 // the best way to do this for wxPython is to have the Python method
2738 // return either a string or None and then act appropriately with the
2739 // C++ version.
2740
2741 bool rval = false;
2742 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2743 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2744 PyObject* ro;
2745 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2746 if (ro) {
2747 rval = (ro != Py_None && PyString_Check(ro));
2748 if (rval)
2749 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2750 Py_DECREF(ro);
2751 }
2752 }
2753 wxPyEndBlockThreads(blocked);
2754 return rval;
2755 }
2756
2757 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2758 // For this one we simply need to make a string from buf and len
2759 // and send it to the Python method.
2760 bool rval = false;
2761 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2762 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2763 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2764 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2765 Py_DECREF(data);
2766 }
2767 wxPyEndBlockThreads(blocked);
2768 return rval;
2769 }
2770
2771 // Create a new class for wxPython to use
2772 class wxPyTextDataObject : public wxTextDataObject {
2773 public:
2774 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2775 : wxTextDataObject(text) {}
2776
2777 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2778 DEC_PYCALLBACK_STRING__const(GetText);
2779 DEC_PYCALLBACK__STRING(SetText);
2780 PYPRIVATE;
2781 };
2782
2783 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2784 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2785 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2786
2787
2788 // Create a new class for wxPython to use
2789 class wxPyBitmapDataObject : public wxBitmapDataObject {
2790 public:
2791 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2792 : wxBitmapDataObject(bitmap) {}
2793
2794 wxBitmap GetBitmap() const;
2795 void SetBitmap(const wxBitmap& bitmap);
2796 PYPRIVATE;
2797 };
2798
2799 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2800 wxBitmap* rval = &wxNullBitmap;
2801 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2802 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2803 PyObject* ro;
2804 wxBitmap* ptr;
2805 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2806 if (ro) {
2807 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2808 rval = ptr;
2809 Py_DECREF(ro);
2810 }
2811 }
2812 wxPyEndBlockThreads(blocked);
2813 return *rval;
2814 }
2815
2816 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2817 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2818 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2819 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2820 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2821 Py_DECREF(bo);
2822 }
2823 wxPyEndBlockThreads(blocked);
2824 }
2825
2826 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2827 return new wxCustomDataObject(wxDataFormat(formatName));
2828 }
2829 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2830 bool rval;
2831 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2832 if (PyString_Check(data)) {
2833 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2834 }
2835 else {
2836 // raise a TypeError if not a string
2837 PyErr_SetString(PyExc_TypeError, "String expected.");
2838 rval = false;
2839 }
2840 wxPyEndBlockThreads(blocked);
2841 return rval;
2842 }
2843 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2844 PyObject* obj;
2845 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2846 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2847 wxPyEndBlockThreads(blocked);
2848 return obj;
2849 }
2850
2851 class wxMetafileDataObject : public wxDataObjectSimple
2852 {
2853 public:
2854 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2855 };
2856
2857
2858 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2859
2860
2861 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2862 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2863 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2864 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2865 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2866
2867
2868 class wxPyTextDropTarget : public wxTextDropTarget {
2869 public:
2870 wxPyTextDropTarget() {}
2871
2872 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2873
2874 DEC_PYCALLBACK__(OnLeave);
2875 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2876 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2877 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2878 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2879
2880 PYPRIVATE;
2881 };
2882
2883 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2884 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2885 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2886 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2887 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2888 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2889
2890
2891
2892 class wxPyFileDropTarget : public wxFileDropTarget {
2893 public:
2894 wxPyFileDropTarget() {}
2895
2896 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2897
2898 DEC_PYCALLBACK__(OnLeave);
2899 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2900 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2901 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2902 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2903
2904 PYPRIVATE;
2905 };
2906
2907 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2908 const wxArrayString& filenames) {
2909 bool rval = false;
2910 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2911 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2912 PyObject* list = wxArrayString2PyList_helper(filenames);
2913 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2914 Py_DECREF(list);
2915 }
2916 wxPyEndBlockThreads(blocked);
2917 return rval;
2918 }
2919
2920
2921
2922 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2923 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2924 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2925 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2926 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2927
2928
2929
2930
2931 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2932
2933 #include <wx/display.h>
2934
2935 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2936 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2937
2938 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2939 #if !wxUSE_DISPLAY
2940 #include <wx/dynarray.h>
2941 #include <wx/vidmode.h>
2942
2943 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2944 #include "wx/arrimpl.cpp"
2945 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2946 const wxVideoMode wxDefaultVideoMode;
2947
2948 class wxDisplay
2949 {
2950 public:
2951 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2952 ~wxDisplay() {}
2953
2954 static size_t GetCount()
2955 { wxPyRaiseNotImplemented(); return 0; }
2956
2957 static int GetFromPoint(const wxPoint& pt)
2958 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2959 static int GetFromWindow(wxWindow *window)
2960 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2961
2962 virtual bool IsOk() const { return false; }
2963 virtual wxRect GetGeometry() const { wxRect r; return r; }
2964 virtual wxString GetName() const { return wxEmptyString; }
2965 bool IsPrimary() const { return false; }
2966
2967 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2968 { wxArrayVideoModes a; return a; }
2969
2970 virtual wxVideoMode GetCurrentMode() const
2971 { return wxDefaultVideoMode; }
2972
2973 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2974 { return false; }
2975
2976 void ResetMode() {}
2977 };
2978 #endif
2979
2980 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2981 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2982 PyObject* pyList = NULL;
2983 wxArrayVideoModes arr = self->GetModes(mode);
2984 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2985 pyList = PyList_New(0);
2986 for (int i=0; i < arr.GetCount(); i++) {
2987 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2988 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2989 PyList_Append(pyList, pyObj);
2990 Py_DECREF(pyObj);
2991 }
2992 wxPyEndBlockThreads(blocked);
2993 return pyList;
2994 }
2995
2996 #include <wx/stdpaths.h>
2997
2998 static wxStandardPaths *StandardPaths_Get(){
2999 return (wxStandardPaths*) &wxStandardPaths::Get();
3000 }
3001 #ifdef __cplusplus
3002 extern "C" {
3003 #endif
3004 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3005 PyObject *resultobj;
3006 wxSystemColour arg1 ;
3007 wxColour result;
3008 PyObject * obj0 = 0 ;
3009 char *kwnames[] = {
3010 (char *) "index", NULL
3011 };
3012
3013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3014 {
3015 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3016 if (SWIG_arg_fail(1)) SWIG_fail;
3017 }
3018 {
3019 if (!wxPyCheckForApp()) SWIG_fail;
3020 PyThreadState* __tstate = wxPyBeginAllowThreads();
3021 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3022
3023 wxPyEndAllowThreads(__tstate);
3024 if (PyErr_Occurred()) SWIG_fail;
3025 }
3026 {
3027 wxColour * resultptr;
3028 resultptr = new wxColour((wxColour &)(result));
3029 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3030 }
3031 return resultobj;
3032 fail:
3033 return NULL;
3034 }
3035
3036
3037 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3038 PyObject *resultobj;
3039 wxSystemFont arg1 ;
3040 wxFont result;
3041 PyObject * obj0 = 0 ;
3042 char *kwnames[] = {
3043 (char *) "index", NULL
3044 };
3045
3046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3047 {
3048 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3049 if (SWIG_arg_fail(1)) SWIG_fail;
3050 }
3051 {
3052 if (!wxPyCheckForApp()) SWIG_fail;
3053 PyThreadState* __tstate = wxPyBeginAllowThreads();
3054 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3055
3056 wxPyEndAllowThreads(__tstate);
3057 if (PyErr_Occurred()) SWIG_fail;
3058 }
3059 {
3060 wxFont * resultptr;
3061 resultptr = new wxFont((wxFont &)(result));
3062 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3063 }
3064 return resultobj;
3065 fail:
3066 return NULL;
3067 }
3068
3069
3070 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3071 PyObject *resultobj;
3072 wxSystemMetric arg1 ;
3073 wxWindow *arg2 = (wxWindow *) NULL ;
3074 int result;
3075 PyObject * obj0 = 0 ;
3076 PyObject * obj1 = 0 ;
3077 char *kwnames[] = {
3078 (char *) "index",(char *) "win", NULL
3079 };
3080
3081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3082 {
3083 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3084 if (SWIG_arg_fail(1)) SWIG_fail;
3085 }
3086 if (obj1) {
3087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3088 if (SWIG_arg_fail(2)) SWIG_fail;
3089 }
3090 {
3091 if (!wxPyCheckForApp()) SWIG_fail;
3092 PyThreadState* __tstate = wxPyBeginAllowThreads();
3093 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3094
3095 wxPyEndAllowThreads(__tstate);
3096 if (PyErr_Occurred()) SWIG_fail;
3097 }
3098 {
3099 resultobj = SWIG_From_int((int)(result));
3100 }
3101 return resultobj;
3102 fail:
3103 return NULL;
3104 }
3105
3106
3107 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3108 PyObject *resultobj;
3109 wxSystemFeature arg1 ;
3110 bool result;
3111 PyObject * obj0 = 0 ;
3112 char *kwnames[] = {
3113 (char *) "index", NULL
3114 };
3115
3116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3117 {
3118 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3119 if (SWIG_arg_fail(1)) SWIG_fail;
3120 }
3121 {
3122 if (!wxPyCheckForApp()) SWIG_fail;
3123 PyThreadState* __tstate = wxPyBeginAllowThreads();
3124 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3125
3126 wxPyEndAllowThreads(__tstate);
3127 if (PyErr_Occurred()) SWIG_fail;
3128 }
3129 {
3130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3131 }
3132 return resultobj;
3133 fail:
3134 return NULL;
3135 }
3136
3137
3138 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3139 PyObject *resultobj;
3140 wxSystemScreenType result;
3141 char *kwnames[] = {
3142 NULL
3143 };
3144
3145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3146 {
3147 if (!wxPyCheckForApp()) SWIG_fail;
3148 PyThreadState* __tstate = wxPyBeginAllowThreads();
3149 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3150
3151 wxPyEndAllowThreads(__tstate);
3152 if (PyErr_Occurred()) SWIG_fail;
3153 }
3154 resultobj = SWIG_From_int((result));
3155 return resultobj;
3156 fail:
3157 return NULL;
3158 }
3159
3160
3161 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3162 PyObject *resultobj;
3163 wxSystemScreenType arg1 ;
3164 PyObject * obj0 = 0 ;
3165 char *kwnames[] = {
3166 (char *) "screen", NULL
3167 };
3168
3169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3170 {
3171 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3172 if (SWIG_arg_fail(1)) SWIG_fail;
3173 }
3174 {
3175 if (!wxPyCheckForApp()) SWIG_fail;
3176 PyThreadState* __tstate = wxPyBeginAllowThreads();
3177 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3178
3179 wxPyEndAllowThreads(__tstate);
3180 if (PyErr_Occurred()) SWIG_fail;
3181 }
3182 Py_INCREF(Py_None); resultobj = Py_None;
3183 return resultobj;
3184 fail:
3185 return NULL;
3186 }
3187
3188
3189 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3190 PyObject *obj;
3191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3192 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3193 Py_INCREF(obj);
3194 return Py_BuildValue((char *)"");
3195 }
3196 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3197 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3198 return 1;
3199 }
3200
3201
3202 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3203 PyObject *pyobj;
3204
3205 {
3206 #if wxUSE_UNICODE
3207 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3208 #else
3209 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3210 #endif
3211 }
3212 return pyobj;
3213 }
3214
3215
3216 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3217 PyObject *resultobj;
3218 wxSystemOptions *result;
3219 char *kwnames[] = {
3220 NULL
3221 };
3222
3223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3224 {
3225 PyThreadState* __tstate = wxPyBeginAllowThreads();
3226 result = (wxSystemOptions *)new wxSystemOptions();
3227
3228 wxPyEndAllowThreads(__tstate);
3229 if (PyErr_Occurred()) SWIG_fail;
3230 }
3231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3232 return resultobj;
3233 fail:
3234 return NULL;
3235 }
3236
3237
3238 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3239 PyObject *resultobj;
3240 wxString *arg1 = 0 ;
3241 wxString *arg2 = 0 ;
3242 bool temp1 = false ;
3243 bool temp2 = false ;
3244 PyObject * obj0 = 0 ;
3245 PyObject * obj1 = 0 ;
3246 char *kwnames[] = {
3247 (char *) "name",(char *) "value", NULL
3248 };
3249
3250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3251 {
3252 arg1 = wxString_in_helper(obj0);
3253 if (arg1 == NULL) SWIG_fail;
3254 temp1 = true;
3255 }
3256 {
3257 arg2 = wxString_in_helper(obj1);
3258 if (arg2 == NULL) SWIG_fail;
3259 temp2 = true;
3260 }
3261 {
3262 PyThreadState* __tstate = wxPyBeginAllowThreads();
3263 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3264
3265 wxPyEndAllowThreads(__tstate);
3266 if (PyErr_Occurred()) SWIG_fail;
3267 }
3268 Py_INCREF(Py_None); resultobj = Py_None;
3269 {
3270 if (temp1)
3271 delete arg1;
3272 }
3273 {
3274 if (temp2)
3275 delete arg2;
3276 }
3277 return resultobj;
3278 fail:
3279 {
3280 if (temp1)
3281 delete arg1;
3282 }
3283 {
3284 if (temp2)
3285 delete arg2;
3286 }
3287 return NULL;
3288 }
3289
3290
3291 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3292 PyObject *resultobj;
3293 wxString *arg1 = 0 ;
3294 int arg2 ;
3295 bool temp1 = false ;
3296 PyObject * obj0 = 0 ;
3297 PyObject * obj1 = 0 ;
3298 char *kwnames[] = {
3299 (char *) "name",(char *) "value", NULL
3300 };
3301
3302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3303 {
3304 arg1 = wxString_in_helper(obj0);
3305 if (arg1 == NULL) SWIG_fail;
3306 temp1 = true;
3307 }
3308 {
3309 arg2 = (int)(SWIG_As_int(obj1));
3310 if (SWIG_arg_fail(2)) SWIG_fail;
3311 }
3312 {
3313 PyThreadState* __tstate = wxPyBeginAllowThreads();
3314 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3315
3316 wxPyEndAllowThreads(__tstate);
3317 if (PyErr_Occurred()) SWIG_fail;
3318 }
3319 Py_INCREF(Py_None); resultobj = Py_None;
3320 {
3321 if (temp1)
3322 delete arg1;
3323 }
3324 return resultobj;
3325 fail:
3326 {
3327 if (temp1)
3328 delete arg1;
3329 }
3330 return NULL;
3331 }
3332
3333
3334 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3335 PyObject *resultobj;
3336 wxString *arg1 = 0 ;
3337 wxString result;
3338 bool temp1 = false ;
3339 PyObject * obj0 = 0 ;
3340 char *kwnames[] = {
3341 (char *) "name", NULL
3342 };
3343
3344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3345 {
3346 arg1 = wxString_in_helper(obj0);
3347 if (arg1 == NULL) SWIG_fail;
3348 temp1 = true;
3349 }
3350 {
3351 PyThreadState* __tstate = wxPyBeginAllowThreads();
3352 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3353
3354 wxPyEndAllowThreads(__tstate);
3355 if (PyErr_Occurred()) SWIG_fail;
3356 }
3357 {
3358 #if wxUSE_UNICODE
3359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3360 #else
3361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3362 #endif
3363 }
3364 {
3365 if (temp1)
3366 delete arg1;
3367 }
3368 return resultobj;
3369 fail:
3370 {
3371 if (temp1)
3372 delete arg1;
3373 }
3374 return NULL;
3375 }
3376
3377
3378 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3379 PyObject *resultobj;
3380 wxString *arg1 = 0 ;
3381 int result;
3382 bool temp1 = false ;
3383 PyObject * obj0 = 0 ;
3384 char *kwnames[] = {
3385 (char *) "name", NULL
3386 };
3387
3388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3389 {
3390 arg1 = wxString_in_helper(obj0);
3391 if (arg1 == NULL) SWIG_fail;
3392 temp1 = true;
3393 }
3394 {
3395 PyThreadState* __tstate = wxPyBeginAllowThreads();
3396 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3397
3398 wxPyEndAllowThreads(__tstate);
3399 if (PyErr_Occurred()) SWIG_fail;
3400 }
3401 {
3402 resultobj = SWIG_From_int((int)(result));
3403 }
3404 {
3405 if (temp1)
3406 delete arg1;
3407 }
3408 return resultobj;
3409 fail:
3410 {
3411 if (temp1)
3412 delete arg1;
3413 }
3414 return NULL;
3415 }
3416
3417
3418 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3419 PyObject *resultobj;
3420 wxString *arg1 = 0 ;
3421 bool result;
3422 bool temp1 = false ;
3423 PyObject * obj0 = 0 ;
3424 char *kwnames[] = {
3425 (char *) "name", NULL
3426 };
3427
3428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3429 {
3430 arg1 = wxString_in_helper(obj0);
3431 if (arg1 == NULL) SWIG_fail;
3432 temp1 = true;
3433 }
3434 {
3435 PyThreadState* __tstate = wxPyBeginAllowThreads();
3436 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3437
3438 wxPyEndAllowThreads(__tstate);
3439 if (PyErr_Occurred()) SWIG_fail;
3440 }
3441 {
3442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3443 }
3444 {
3445 if (temp1)
3446 delete arg1;
3447 }
3448 return resultobj;
3449 fail:
3450 {
3451 if (temp1)
3452 delete arg1;
3453 }
3454 return NULL;
3455 }
3456
3457
3458 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3459 PyObject *resultobj;
3460 wxString *arg1 = 0 ;
3461 bool result;
3462 bool temp1 = false ;
3463 PyObject * obj0 = 0 ;
3464 char *kwnames[] = {
3465 (char *) "name", NULL
3466 };
3467
3468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3469 {
3470 arg1 = wxString_in_helper(obj0);
3471 if (arg1 == NULL) SWIG_fail;
3472 temp1 = true;
3473 }
3474 {
3475 PyThreadState* __tstate = wxPyBeginAllowThreads();
3476 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3477
3478 wxPyEndAllowThreads(__tstate);
3479 if (PyErr_Occurred()) SWIG_fail;
3480 }
3481 {
3482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3483 }
3484 {
3485 if (temp1)
3486 delete arg1;
3487 }
3488 return resultobj;
3489 fail:
3490 {
3491 if (temp1)
3492 delete arg1;
3493 }
3494 return NULL;
3495 }
3496
3497
3498 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3499 PyObject *obj;
3500 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3501 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3502 Py_INCREF(obj);
3503 return Py_BuildValue((char *)"");
3504 }
3505 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3506 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3507 return 1;
3508 }
3509
3510
3511 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3512 PyObject *pyobj;
3513
3514 {
3515 #if wxUSE_UNICODE
3516 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3517 #else
3518 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3519 #endif
3520 }
3521 return pyobj;
3522 }
3523
3524
3525 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3526 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3527 return 1;
3528 }
3529
3530
3531 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3532 PyObject *pyobj;
3533
3534 {
3535 #if wxUSE_UNICODE
3536 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3537 #else
3538 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3539 #endif
3540 }
3541 return pyobj;
3542 }
3543
3544
3545 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3546 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3547 return 1;
3548 }
3549
3550
3551 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3552 PyObject *pyobj;
3553
3554 {
3555 #if wxUSE_UNICODE
3556 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3557 #else
3558 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3559 #endif
3560 }
3561 return pyobj;
3562 }
3563
3564
3565 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3566 PyObject *resultobj;
3567 long result;
3568 char *kwnames[] = {
3569 NULL
3570 };
3571
3572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3573 {
3574 PyThreadState* __tstate = wxPyBeginAllowThreads();
3575 result = (long)wxNewId();
3576
3577 wxPyEndAllowThreads(__tstate);
3578 if (PyErr_Occurred()) SWIG_fail;
3579 }
3580 {
3581 resultobj = SWIG_From_long((long)(result));
3582 }
3583 return resultobj;
3584 fail:
3585 return NULL;
3586 }
3587
3588
3589 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3590 PyObject *resultobj;
3591 long arg1 ;
3592 PyObject * obj0 = 0 ;
3593 char *kwnames[] = {
3594 (char *) "id", NULL
3595 };
3596
3597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3598 {
3599 arg1 = (long)(SWIG_As_long(obj0));
3600 if (SWIG_arg_fail(1)) SWIG_fail;
3601 }
3602 {
3603 PyThreadState* __tstate = wxPyBeginAllowThreads();
3604 wxRegisterId(arg1);
3605
3606 wxPyEndAllowThreads(__tstate);
3607 if (PyErr_Occurred()) SWIG_fail;
3608 }
3609 Py_INCREF(Py_None); resultobj = Py_None;
3610 return resultobj;
3611 fail:
3612 return NULL;
3613 }
3614
3615
3616 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3617 PyObject *resultobj;
3618 long result;
3619 char *kwnames[] = {
3620 NULL
3621 };
3622
3623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3624 {
3625 PyThreadState* __tstate = wxPyBeginAllowThreads();
3626 result = (long)wxGetCurrentId();
3627
3628 wxPyEndAllowThreads(__tstate);
3629 if (PyErr_Occurred()) SWIG_fail;
3630 }
3631 {
3632 resultobj = SWIG_From_long((long)(result));
3633 }
3634 return resultobj;
3635 fail:
3636 return NULL;
3637 }
3638
3639
3640 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3641 PyObject *resultobj;
3642 int arg1 ;
3643 bool result;
3644 PyObject * obj0 = 0 ;
3645 char *kwnames[] = {
3646 (char *) "id", NULL
3647 };
3648
3649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3650 {
3651 arg1 = (int)(SWIG_As_int(obj0));
3652 if (SWIG_arg_fail(1)) SWIG_fail;
3653 }
3654 {
3655 PyThreadState* __tstate = wxPyBeginAllowThreads();
3656 result = (bool)wxIsStockID(arg1);
3657
3658 wxPyEndAllowThreads(__tstate);
3659 if (PyErr_Occurred()) SWIG_fail;
3660 }
3661 {
3662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3663 }
3664 return resultobj;
3665 fail:
3666 return NULL;
3667 }
3668
3669
3670 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3671 PyObject *resultobj;
3672 int arg1 ;
3673 wxString *arg2 = 0 ;
3674 bool result;
3675 bool temp2 = false ;
3676 PyObject * obj0 = 0 ;
3677 PyObject * obj1 = 0 ;
3678 char *kwnames[] = {
3679 (char *) "id",(char *) "label", NULL
3680 };
3681
3682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3683 {
3684 arg1 = (int)(SWIG_As_int(obj0));
3685 if (SWIG_arg_fail(1)) SWIG_fail;
3686 }
3687 {
3688 arg2 = wxString_in_helper(obj1);
3689 if (arg2 == NULL) SWIG_fail;
3690 temp2 = true;
3691 }
3692 {
3693 PyThreadState* __tstate = wxPyBeginAllowThreads();
3694 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3695
3696 wxPyEndAllowThreads(__tstate);
3697 if (PyErr_Occurred()) SWIG_fail;
3698 }
3699 {
3700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3701 }
3702 {
3703 if (temp2)
3704 delete arg2;
3705 }
3706 return resultobj;
3707 fail:
3708 {
3709 if (temp2)
3710 delete arg2;
3711 }
3712 return NULL;
3713 }
3714
3715
3716 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3717 PyObject *resultobj;
3718 int arg1 ;
3719 bool arg2 = (bool) true ;
3720 wxString arg3 = (wxString) wxPyEmptyString ;
3721 wxString result;
3722 PyObject * obj0 = 0 ;
3723 PyObject * obj1 = 0 ;
3724 PyObject * obj2 = 0 ;
3725 char *kwnames[] = {
3726 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3727 };
3728
3729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3730 {
3731 arg1 = (int)(SWIG_As_int(obj0));
3732 if (SWIG_arg_fail(1)) SWIG_fail;
3733 }
3734 if (obj1) {
3735 {
3736 arg2 = (bool)(SWIG_As_bool(obj1));
3737 if (SWIG_arg_fail(2)) SWIG_fail;
3738 }
3739 }
3740 if (obj2) {
3741 {
3742 wxString* sptr = wxString_in_helper(obj2);
3743 if (sptr == NULL) SWIG_fail;
3744 arg3 = *sptr;
3745 delete sptr;
3746 }
3747 }
3748 {
3749 PyThreadState* __tstate = wxPyBeginAllowThreads();
3750 result = wxGetStockLabel(arg1,arg2,arg3);
3751
3752 wxPyEndAllowThreads(__tstate);
3753 if (PyErr_Occurred()) SWIG_fail;
3754 }
3755 {
3756 #if wxUSE_UNICODE
3757 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3758 #else
3759 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3760 #endif
3761 }
3762 return resultobj;
3763 fail:
3764 return NULL;
3765 }
3766
3767
3768 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3769 PyObject *resultobj;
3770 char *kwnames[] = {
3771 NULL
3772 };
3773
3774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3775 {
3776 if (!wxPyCheckForApp()) SWIG_fail;
3777 PyThreadState* __tstate = wxPyBeginAllowThreads();
3778 wxBell();
3779
3780 wxPyEndAllowThreads(__tstate);
3781 if (PyErr_Occurred()) SWIG_fail;
3782 }
3783 Py_INCREF(Py_None); resultobj = Py_None;
3784 return resultobj;
3785 fail:
3786 return NULL;
3787 }
3788
3789
3790 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3791 PyObject *resultobj;
3792 char *kwnames[] = {
3793 NULL
3794 };
3795
3796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3797 {
3798 if (!wxPyCheckForApp()) SWIG_fail;
3799 PyThreadState* __tstate = wxPyBeginAllowThreads();
3800 wxEndBusyCursor();
3801
3802 wxPyEndAllowThreads(__tstate);
3803 if (PyErr_Occurred()) SWIG_fail;
3804 }
3805 Py_INCREF(Py_None); resultobj = Py_None;
3806 return resultobj;
3807 fail:
3808 return NULL;
3809 }
3810
3811
3812 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3813 PyObject *resultobj;
3814 bool arg1 = (bool) true ;
3815 long result;
3816 PyObject * obj0 = 0 ;
3817 char *kwnames[] = {
3818 (char *) "resetTimer", NULL
3819 };
3820
3821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3822 if (obj0) {
3823 {
3824 arg1 = (bool)(SWIG_As_bool(obj0));
3825 if (SWIG_arg_fail(1)) SWIG_fail;
3826 }
3827 }
3828 {
3829 PyThreadState* __tstate = wxPyBeginAllowThreads();
3830 result = (long)wxGetElapsedTime(arg1);
3831
3832 wxPyEndAllowThreads(__tstate);
3833 if (PyErr_Occurred()) SWIG_fail;
3834 }
3835 {
3836 resultobj = SWIG_From_long((long)(result));
3837 }
3838 return resultobj;
3839 fail:
3840 return NULL;
3841 }
3842
3843
3844 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3845 PyObject *resultobj;
3846 int *arg1 = (int *) 0 ;
3847 int *arg2 = (int *) 0 ;
3848 int temp1 ;
3849 int res1 = 0 ;
3850 int temp2 ;
3851 int res2 = 0 ;
3852 char *kwnames[] = {
3853 NULL
3854 };
3855
3856 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3857 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3859 {
3860 if (!wxPyCheckForApp()) SWIG_fail;
3861 PyThreadState* __tstate = wxPyBeginAllowThreads();
3862 wxGetMousePosition(arg1,arg2);
3863
3864 wxPyEndAllowThreads(__tstate);
3865 if (PyErr_Occurred()) SWIG_fail;
3866 }
3867 Py_INCREF(Py_None); resultobj = Py_None;
3868 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3869 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3870 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3871 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3872 return resultobj;
3873 fail:
3874 return NULL;
3875 }
3876
3877
3878 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3879 PyObject *resultobj;
3880 bool result;
3881 char *kwnames[] = {
3882 NULL
3883 };
3884
3885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3886 {
3887 PyThreadState* __tstate = wxPyBeginAllowThreads();
3888 result = (bool)wxIsBusy();
3889
3890 wxPyEndAllowThreads(__tstate);
3891 if (PyErr_Occurred()) SWIG_fail;
3892 }
3893 {
3894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3895 }
3896 return resultobj;
3897 fail:
3898 return NULL;
3899 }
3900
3901
3902 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3903 PyObject *resultobj;
3904 wxString result;
3905 char *kwnames[] = {
3906 NULL
3907 };
3908
3909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3910 {
3911 PyThreadState* __tstate = wxPyBeginAllowThreads();
3912 result = wxNow();
3913
3914 wxPyEndAllowThreads(__tstate);
3915 if (PyErr_Occurred()) SWIG_fail;
3916 }
3917 {
3918 #if wxUSE_UNICODE
3919 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3920 #else
3921 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3922 #endif
3923 }
3924 return resultobj;
3925 fail:
3926 return NULL;
3927 }
3928
3929
3930 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3931 PyObject *resultobj;
3932 wxString const &arg1_defvalue = wxPyEmptyString ;
3933 wxString *arg1 = (wxString *) &arg1_defvalue ;
3934 bool result;
3935 bool temp1 = false ;
3936 PyObject * obj0 = 0 ;
3937 char *kwnames[] = {
3938 (char *) "command", NULL
3939 };
3940
3941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3942 if (obj0) {
3943 {
3944 arg1 = wxString_in_helper(obj0);
3945 if (arg1 == NULL) SWIG_fail;
3946 temp1 = true;
3947 }
3948 }
3949 {
3950 PyThreadState* __tstate = wxPyBeginAllowThreads();
3951 result = (bool)wxShell((wxString const &)*arg1);
3952
3953 wxPyEndAllowThreads(__tstate);
3954 if (PyErr_Occurred()) SWIG_fail;
3955 }
3956 {
3957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3958 }
3959 {
3960 if (temp1)
3961 delete arg1;
3962 }
3963 return resultobj;
3964 fail:
3965 {
3966 if (temp1)
3967 delete arg1;
3968 }
3969 return NULL;
3970 }
3971
3972
3973 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3974 PyObject *resultobj;
3975 char *kwnames[] = {
3976 NULL
3977 };
3978
3979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3980 {
3981 PyThreadState* __tstate = wxPyBeginAllowThreads();
3982 wxStartTimer();
3983
3984 wxPyEndAllowThreads(__tstate);
3985 if (PyErr_Occurred()) SWIG_fail;
3986 }
3987 Py_INCREF(Py_None); resultobj = Py_None;
3988 return resultobj;
3989 fail:
3990 return NULL;
3991 }
3992
3993
3994 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3995 PyObject *resultobj;
3996 int *arg1 = (int *) 0 ;
3997 int *arg2 = (int *) 0 ;
3998 int result;
3999 int temp1 ;
4000 int res1 = 0 ;
4001 int temp2 ;
4002 int res2 = 0 ;
4003 char *kwnames[] = {
4004 NULL
4005 };
4006
4007 arg1 = &temp1; res1 = SWIG_NEWOBJ;
4008 arg2 = &temp2; res2 = SWIG_NEWOBJ;
4009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
4010 {
4011 PyThreadState* __tstate = wxPyBeginAllowThreads();
4012 result = (int)wxGetOsVersion(arg1,arg2);
4013
4014 wxPyEndAllowThreads(__tstate);
4015 if (PyErr_Occurred()) SWIG_fail;
4016 }
4017 {
4018 resultobj = SWIG_From_int((int)(result));
4019 }
4020 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4021 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4022 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4023 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4024 return resultobj;
4025 fail:
4026 return NULL;
4027 }
4028
4029
4030 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4031 PyObject *resultobj;
4032 wxString result;
4033 char *kwnames[] = {
4034 NULL
4035 };
4036
4037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4038 {
4039 PyThreadState* __tstate = wxPyBeginAllowThreads();
4040 result = wxGetOsDescription();
4041
4042 wxPyEndAllowThreads(__tstate);
4043 if (PyErr_Occurred()) SWIG_fail;
4044 }
4045 {
4046 #if wxUSE_UNICODE
4047 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4048 #else
4049 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4050 #endif
4051 }
4052 return resultobj;
4053 fail:
4054 return NULL;
4055 }
4056
4057
4058 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4059 PyObject *resultobj;
4060 long result;
4061 char *kwnames[] = {
4062 NULL
4063 };
4064
4065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4066 {
4067 PyThreadState* __tstate = wxPyBeginAllowThreads();
4068 result = (long)wxGetFreeMemory();
4069
4070 wxPyEndAllowThreads(__tstate);
4071 if (PyErr_Occurred()) SWIG_fail;
4072 }
4073 {
4074 resultobj = SWIG_From_long((long)(result));
4075 }
4076 return resultobj;
4077 fail:
4078 return NULL;
4079 }
4080
4081
4082 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4083 PyObject *resultobj;
4084 wxShutdownFlags arg1 ;
4085 bool result;
4086 PyObject * obj0 = 0 ;
4087 char *kwnames[] = {
4088 (char *) "wFlags", NULL
4089 };
4090
4091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4092 {
4093 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4094 if (SWIG_arg_fail(1)) SWIG_fail;
4095 }
4096 {
4097 if (!wxPyCheckForApp()) SWIG_fail;
4098 PyThreadState* __tstate = wxPyBeginAllowThreads();
4099 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4100
4101 wxPyEndAllowThreads(__tstate);
4102 if (PyErr_Occurred()) SWIG_fail;
4103 }
4104 {
4105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4106 }
4107 return resultobj;
4108 fail:
4109 return NULL;
4110 }
4111
4112
4113 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4114 PyObject *resultobj;
4115 int arg1 ;
4116 PyObject * obj0 = 0 ;
4117 char *kwnames[] = {
4118 (char *) "secs", NULL
4119 };
4120
4121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4122 {
4123 arg1 = (int)(SWIG_As_int(obj0));
4124 if (SWIG_arg_fail(1)) SWIG_fail;
4125 }
4126 {
4127 PyThreadState* __tstate = wxPyBeginAllowThreads();
4128 wxSleep(arg1);
4129
4130 wxPyEndAllowThreads(__tstate);
4131 if (PyErr_Occurred()) SWIG_fail;
4132 }
4133 Py_INCREF(Py_None); resultobj = Py_None;
4134 return resultobj;
4135 fail:
4136 return NULL;
4137 }
4138
4139
4140 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4141 PyObject *resultobj;
4142 unsigned long arg1 ;
4143 PyObject * obj0 = 0 ;
4144 char *kwnames[] = {
4145 (char *) "milliseconds", NULL
4146 };
4147
4148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4149 {
4150 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4151 if (SWIG_arg_fail(1)) SWIG_fail;
4152 }
4153 {
4154 PyThreadState* __tstate = wxPyBeginAllowThreads();
4155 wxMilliSleep(arg1);
4156
4157 wxPyEndAllowThreads(__tstate);
4158 if (PyErr_Occurred()) SWIG_fail;
4159 }
4160 Py_INCREF(Py_None); resultobj = Py_None;
4161 return resultobj;
4162 fail:
4163 return NULL;
4164 }
4165
4166
4167 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4168 PyObject *resultobj;
4169 unsigned long arg1 ;
4170 PyObject * obj0 = 0 ;
4171 char *kwnames[] = {
4172 (char *) "microseconds", NULL
4173 };
4174
4175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4176 {
4177 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4178 if (SWIG_arg_fail(1)) SWIG_fail;
4179 }
4180 {
4181 PyThreadState* __tstate = wxPyBeginAllowThreads();
4182 wxMicroSleep(arg1);
4183
4184 wxPyEndAllowThreads(__tstate);
4185 if (PyErr_Occurred()) SWIG_fail;
4186 }
4187 Py_INCREF(Py_None); resultobj = Py_None;
4188 return resultobj;
4189 fail:
4190 return NULL;
4191 }
4192
4193
4194 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4195 PyObject *resultobj;
4196 bool arg1 ;
4197 PyObject * obj0 = 0 ;
4198 char *kwnames[] = {
4199 (char *) "enable", NULL
4200 };
4201
4202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4203 {
4204 arg1 = (bool)(SWIG_As_bool(obj0));
4205 if (SWIG_arg_fail(1)) SWIG_fail;
4206 }
4207 {
4208 PyThreadState* __tstate = wxPyBeginAllowThreads();
4209 wxEnableTopLevelWindows(arg1);
4210
4211 wxPyEndAllowThreads(__tstate);
4212 if (PyErr_Occurred()) SWIG_fail;
4213 }
4214 Py_INCREF(Py_None); resultobj = Py_None;
4215 return resultobj;
4216 fail:
4217 return NULL;
4218 }
4219
4220
4221 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4222 PyObject *resultobj;
4223 wxString *arg1 = 0 ;
4224 wxString result;
4225 bool temp1 = false ;
4226 PyObject * obj0 = 0 ;
4227 char *kwnames[] = {
4228 (char *) "in", NULL
4229 };
4230
4231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4232 {
4233 arg1 = wxString_in_helper(obj0);
4234 if (arg1 == NULL) SWIG_fail;
4235 temp1 = true;
4236 }
4237 {
4238 PyThreadState* __tstate = wxPyBeginAllowThreads();
4239 result = wxStripMenuCodes((wxString const &)*arg1);
4240
4241 wxPyEndAllowThreads(__tstate);
4242 if (PyErr_Occurred()) SWIG_fail;
4243 }
4244 {
4245 #if wxUSE_UNICODE
4246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4247 #else
4248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4249 #endif
4250 }
4251 {
4252 if (temp1)
4253 delete arg1;
4254 }
4255 return resultobj;
4256 fail:
4257 {
4258 if (temp1)
4259 delete arg1;
4260 }
4261 return NULL;
4262 }
4263
4264
4265 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4266 PyObject *resultobj;
4267 wxString result;
4268 char *kwnames[] = {
4269 NULL
4270 };
4271
4272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4273 {
4274 PyThreadState* __tstate = wxPyBeginAllowThreads();
4275 result = wxGetEmailAddress();
4276
4277 wxPyEndAllowThreads(__tstate);
4278 if (PyErr_Occurred()) SWIG_fail;
4279 }
4280 {
4281 #if wxUSE_UNICODE
4282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4283 #else
4284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4285 #endif
4286 }
4287 return resultobj;
4288 fail:
4289 return NULL;
4290 }
4291
4292
4293 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4294 PyObject *resultobj;
4295 wxString result;
4296 char *kwnames[] = {
4297 NULL
4298 };
4299
4300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4301 {
4302 PyThreadState* __tstate = wxPyBeginAllowThreads();
4303 result = wxGetHostName();
4304
4305 wxPyEndAllowThreads(__tstate);
4306 if (PyErr_Occurred()) SWIG_fail;
4307 }
4308 {
4309 #if wxUSE_UNICODE
4310 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4311 #else
4312 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4313 #endif
4314 }
4315 return resultobj;
4316 fail:
4317 return NULL;
4318 }
4319
4320
4321 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4322 PyObject *resultobj;
4323 wxString result;
4324 char *kwnames[] = {
4325 NULL
4326 };
4327
4328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4329 {
4330 PyThreadState* __tstate = wxPyBeginAllowThreads();
4331 result = wxGetFullHostName();
4332
4333 wxPyEndAllowThreads(__tstate);
4334 if (PyErr_Occurred()) SWIG_fail;
4335 }
4336 {
4337 #if wxUSE_UNICODE
4338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4339 #else
4340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4341 #endif
4342 }
4343 return resultobj;
4344 fail:
4345 return NULL;
4346 }
4347
4348
4349 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4350 PyObject *resultobj;
4351 wxString result;
4352 char *kwnames[] = {
4353 NULL
4354 };
4355
4356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4357 {
4358 PyThreadState* __tstate = wxPyBeginAllowThreads();
4359 result = wxGetUserId();
4360
4361 wxPyEndAllowThreads(__tstate);
4362 if (PyErr_Occurred()) SWIG_fail;
4363 }
4364 {
4365 #if wxUSE_UNICODE
4366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4367 #else
4368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4369 #endif
4370 }
4371 return resultobj;
4372 fail:
4373 return NULL;
4374 }
4375
4376
4377 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4378 PyObject *resultobj;
4379 wxString result;
4380 char *kwnames[] = {
4381 NULL
4382 };
4383
4384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4385 {
4386 PyThreadState* __tstate = wxPyBeginAllowThreads();
4387 result = wxGetUserName();
4388
4389 wxPyEndAllowThreads(__tstate);
4390 if (PyErr_Occurred()) SWIG_fail;
4391 }
4392 {
4393 #if wxUSE_UNICODE
4394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4395 #else
4396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4397 #endif
4398 }
4399 return resultobj;
4400 fail:
4401 return NULL;
4402 }
4403
4404
4405 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4406 PyObject *resultobj;
4407 wxString result;
4408 char *kwnames[] = {
4409 NULL
4410 };
4411
4412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4413 {
4414 PyThreadState* __tstate = wxPyBeginAllowThreads();
4415 result = wxGetHomeDir();
4416
4417 wxPyEndAllowThreads(__tstate);
4418 if (PyErr_Occurred()) SWIG_fail;
4419 }
4420 {
4421 #if wxUSE_UNICODE
4422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4423 #else
4424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4425 #endif
4426 }
4427 return resultobj;
4428 fail:
4429 return NULL;
4430 }
4431
4432
4433 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4434 PyObject *resultobj;
4435 wxString const &arg1_defvalue = wxPyEmptyString ;
4436 wxString *arg1 = (wxString *) &arg1_defvalue ;
4437 wxString result;
4438 bool temp1 = false ;
4439 PyObject * obj0 = 0 ;
4440 char *kwnames[] = {
4441 (char *) "user", NULL
4442 };
4443
4444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4445 if (obj0) {
4446 {
4447 arg1 = wxString_in_helper(obj0);
4448 if (arg1 == NULL) SWIG_fail;
4449 temp1 = true;
4450 }
4451 }
4452 {
4453 PyThreadState* __tstate = wxPyBeginAllowThreads();
4454 result = wxGetUserHome((wxString const &)*arg1);
4455
4456 wxPyEndAllowThreads(__tstate);
4457 if (PyErr_Occurred()) SWIG_fail;
4458 }
4459 {
4460 #if wxUSE_UNICODE
4461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4462 #else
4463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4464 #endif
4465 }
4466 {
4467 if (temp1)
4468 delete arg1;
4469 }
4470 return resultobj;
4471 fail:
4472 {
4473 if (temp1)
4474 delete arg1;
4475 }
4476 return NULL;
4477 }
4478
4479
4480 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4481 PyObject *resultobj;
4482 unsigned long result;
4483 char *kwnames[] = {
4484 NULL
4485 };
4486
4487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4488 {
4489 PyThreadState* __tstate = wxPyBeginAllowThreads();
4490 result = (unsigned long)wxGetProcessId();
4491
4492 wxPyEndAllowThreads(__tstate);
4493 if (PyErr_Occurred()) SWIG_fail;
4494 }
4495 {
4496 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4497 }
4498 return resultobj;
4499 fail:
4500 return NULL;
4501 }
4502
4503
4504 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4505 PyObject *resultobj;
4506 char *kwnames[] = {
4507 NULL
4508 };
4509
4510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4511 {
4512 PyThreadState* __tstate = wxPyBeginAllowThreads();
4513 wxTrap();
4514
4515 wxPyEndAllowThreads(__tstate);
4516 if (PyErr_Occurred()) SWIG_fail;
4517 }
4518 Py_INCREF(Py_None); resultobj = Py_None;
4519 return resultobj;
4520 fail:
4521 return NULL;
4522 }
4523
4524
4525 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4526 PyObject *resultobj;
4527 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4528 wxString *arg1 = (wxString *) &arg1_defvalue ;
4529 wxString const &arg2_defvalue = wxPyEmptyString ;
4530 wxString *arg2 = (wxString *) &arg2_defvalue ;
4531 wxString const &arg3_defvalue = wxPyEmptyString ;
4532 wxString *arg3 = (wxString *) &arg3_defvalue ;
4533 wxString const &arg4_defvalue = wxPyEmptyString ;
4534 wxString *arg4 = (wxString *) &arg4_defvalue ;
4535 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4536 wxString *arg5 = (wxString *) &arg5_defvalue ;
4537 int arg6 = (int) 0 ;
4538 wxWindow *arg7 = (wxWindow *) NULL ;
4539 int arg8 = (int) -1 ;
4540 int arg9 = (int) -1 ;
4541 wxString result;
4542 bool temp1 = false ;
4543 bool temp2 = false ;
4544 bool temp3 = false ;
4545 bool temp4 = false ;
4546 bool temp5 = false ;
4547 PyObject * obj0 = 0 ;
4548 PyObject * obj1 = 0 ;
4549 PyObject * obj2 = 0 ;
4550 PyObject * obj3 = 0 ;
4551 PyObject * obj4 = 0 ;
4552 PyObject * obj5 = 0 ;
4553 PyObject * obj6 = 0 ;
4554 PyObject * obj7 = 0 ;
4555 PyObject * obj8 = 0 ;
4556 char *kwnames[] = {
4557 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4558 };
4559
4560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4561 if (obj0) {
4562 {
4563 arg1 = wxString_in_helper(obj0);
4564 if (arg1 == NULL) SWIG_fail;
4565 temp1 = true;
4566 }
4567 }
4568 if (obj1) {
4569 {
4570 arg2 = wxString_in_helper(obj1);
4571 if (arg2 == NULL) SWIG_fail;
4572 temp2 = true;
4573 }
4574 }
4575 if (obj2) {
4576 {
4577 arg3 = wxString_in_helper(obj2);
4578 if (arg3 == NULL) SWIG_fail;
4579 temp3 = true;
4580 }
4581 }
4582 if (obj3) {
4583 {
4584 arg4 = wxString_in_helper(obj3);
4585 if (arg4 == NULL) SWIG_fail;
4586 temp4 = true;
4587 }
4588 }
4589 if (obj4) {
4590 {
4591 arg5 = wxString_in_helper(obj4);
4592 if (arg5 == NULL) SWIG_fail;
4593 temp5 = true;
4594 }
4595 }
4596 if (obj5) {
4597 {
4598 arg6 = (int)(SWIG_As_int(obj5));
4599 if (SWIG_arg_fail(6)) SWIG_fail;
4600 }
4601 }
4602 if (obj6) {
4603 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4604 if (SWIG_arg_fail(7)) SWIG_fail;
4605 }
4606 if (obj7) {
4607 {
4608 arg8 = (int)(SWIG_As_int(obj7));
4609 if (SWIG_arg_fail(8)) SWIG_fail;
4610 }
4611 }
4612 if (obj8) {
4613 {
4614 arg9 = (int)(SWIG_As_int(obj8));
4615 if (SWIG_arg_fail(9)) SWIG_fail;
4616 }
4617 }
4618 {
4619 if (!wxPyCheckForApp()) SWIG_fail;
4620 PyThreadState* __tstate = wxPyBeginAllowThreads();
4621 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4622
4623 wxPyEndAllowThreads(__tstate);
4624 if (PyErr_Occurred()) SWIG_fail;
4625 }
4626 {
4627 #if wxUSE_UNICODE
4628 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4629 #else
4630 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4631 #endif
4632 }
4633 {
4634 if (temp1)
4635 delete arg1;
4636 }
4637 {
4638 if (temp2)
4639 delete arg2;
4640 }
4641 {
4642 if (temp3)
4643 delete arg3;
4644 }
4645 {
4646 if (temp4)
4647 delete arg4;
4648 }
4649 {
4650 if (temp5)
4651 delete arg5;
4652 }
4653 return resultobj;
4654 fail:
4655 {
4656 if (temp1)
4657 delete arg1;
4658 }
4659 {
4660 if (temp2)
4661 delete arg2;
4662 }
4663 {
4664 if (temp3)
4665 delete arg3;
4666 }
4667 {
4668 if (temp4)
4669 delete arg4;
4670 }
4671 {
4672 if (temp5)
4673 delete arg5;
4674 }
4675 return NULL;
4676 }
4677
4678
4679 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4680 PyObject *resultobj;
4681 wxString *arg1 = 0 ;
4682 wxString *arg2 = 0 ;
4683 wxString const &arg3_defvalue = wxPyEmptyString ;
4684 wxString *arg3 = (wxString *) &arg3_defvalue ;
4685 wxWindow *arg4 = (wxWindow *) NULL ;
4686 wxString result;
4687 bool temp1 = false ;
4688 bool temp2 = false ;
4689 bool temp3 = false ;
4690 PyObject * obj0 = 0 ;
4691 PyObject * obj1 = 0 ;
4692 PyObject * obj2 = 0 ;
4693 PyObject * obj3 = 0 ;
4694 char *kwnames[] = {
4695 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4696 };
4697
4698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4699 {
4700 arg1 = wxString_in_helper(obj0);
4701 if (arg1 == NULL) SWIG_fail;
4702 temp1 = true;
4703 }
4704 {
4705 arg2 = wxString_in_helper(obj1);
4706 if (arg2 == NULL) SWIG_fail;
4707 temp2 = true;
4708 }
4709 if (obj2) {
4710 {
4711 arg3 = wxString_in_helper(obj2);
4712 if (arg3 == NULL) SWIG_fail;
4713 temp3 = true;
4714 }
4715 }
4716 if (obj3) {
4717 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4718 if (SWIG_arg_fail(4)) SWIG_fail;
4719 }
4720 {
4721 if (!wxPyCheckForApp()) SWIG_fail;
4722 PyThreadState* __tstate = wxPyBeginAllowThreads();
4723 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4724
4725 wxPyEndAllowThreads(__tstate);
4726 if (PyErr_Occurred()) SWIG_fail;
4727 }
4728 {
4729 #if wxUSE_UNICODE
4730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4731 #else
4732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4733 #endif
4734 }
4735 {
4736 if (temp1)
4737 delete arg1;
4738 }
4739 {
4740 if (temp2)
4741 delete arg2;
4742 }
4743 {
4744 if (temp3)
4745 delete arg3;
4746 }
4747 return resultobj;
4748 fail:
4749 {
4750 if (temp1)
4751 delete arg1;
4752 }
4753 {
4754 if (temp2)
4755 delete arg2;
4756 }
4757 {
4758 if (temp3)
4759 delete arg3;
4760 }
4761 return NULL;
4762 }
4763
4764
4765 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4766 PyObject *resultobj;
4767 wxString *arg1 = 0 ;
4768 wxString *arg2 = 0 ;
4769 wxString const &arg3_defvalue = wxPyEmptyString ;
4770 wxString *arg3 = (wxString *) &arg3_defvalue ;
4771 wxWindow *arg4 = (wxWindow *) NULL ;
4772 wxString result;
4773 bool temp1 = false ;
4774 bool temp2 = false ;
4775 bool temp3 = false ;
4776 PyObject * obj0 = 0 ;
4777 PyObject * obj1 = 0 ;
4778 PyObject * obj2 = 0 ;
4779 PyObject * obj3 = 0 ;
4780 char *kwnames[] = {
4781 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4782 };
4783
4784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4785 {
4786 arg1 = wxString_in_helper(obj0);
4787 if (arg1 == NULL) SWIG_fail;
4788 temp1 = true;
4789 }
4790 {
4791 arg2 = wxString_in_helper(obj1);
4792 if (arg2 == NULL) SWIG_fail;
4793 temp2 = true;
4794 }
4795 if (obj2) {
4796 {
4797 arg3 = wxString_in_helper(obj2);
4798 if (arg3 == NULL) SWIG_fail;
4799 temp3 = true;
4800 }
4801 }
4802 if (obj3) {
4803 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4804 if (SWIG_arg_fail(4)) SWIG_fail;
4805 }
4806 {
4807 if (!wxPyCheckForApp()) SWIG_fail;
4808 PyThreadState* __tstate = wxPyBeginAllowThreads();
4809 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4810
4811 wxPyEndAllowThreads(__tstate);
4812 if (PyErr_Occurred()) SWIG_fail;
4813 }
4814 {
4815 #if wxUSE_UNICODE
4816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4817 #else
4818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4819 #endif
4820 }
4821 {
4822 if (temp1)
4823 delete arg1;
4824 }
4825 {
4826 if (temp2)
4827 delete arg2;
4828 }
4829 {
4830 if (temp3)
4831 delete arg3;
4832 }
4833 return resultobj;
4834 fail:
4835 {
4836 if (temp1)
4837 delete arg1;
4838 }
4839 {
4840 if (temp2)
4841 delete arg2;
4842 }
4843 {
4844 if (temp3)
4845 delete arg3;
4846 }
4847 return NULL;
4848 }
4849
4850
4851 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4852 PyObject *resultobj;
4853 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4854 wxString *arg1 = (wxString *) &arg1_defvalue ;
4855 wxString const &arg2_defvalue = wxPyEmptyString ;
4856 wxString *arg2 = (wxString *) &arg2_defvalue ;
4857 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4858 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4859 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4860 wxWindow *arg5 = (wxWindow *) NULL ;
4861 wxString result;
4862 bool temp1 = false ;
4863 bool temp2 = false ;
4864 wxPoint temp4 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 PyObject * obj2 = 0 ;
4868 PyObject * obj3 = 0 ;
4869 PyObject * obj4 = 0 ;
4870 char *kwnames[] = {
4871 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4872 };
4873
4874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4875 if (obj0) {
4876 {
4877 arg1 = wxString_in_helper(obj0);
4878 if (arg1 == NULL) SWIG_fail;
4879 temp1 = true;
4880 }
4881 }
4882 if (obj1) {
4883 {
4884 arg2 = wxString_in_helper(obj1);
4885 if (arg2 == NULL) SWIG_fail;
4886 temp2 = true;
4887 }
4888 }
4889 if (obj2) {
4890 {
4891 arg3 = (long)(SWIG_As_long(obj2));
4892 if (SWIG_arg_fail(3)) SWIG_fail;
4893 }
4894 }
4895 if (obj3) {
4896 {
4897 arg4 = &temp4;
4898 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4899 }
4900 }
4901 if (obj4) {
4902 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4903 if (SWIG_arg_fail(5)) SWIG_fail;
4904 }
4905 {
4906 if (!wxPyCheckForApp()) SWIG_fail;
4907 PyThreadState* __tstate = wxPyBeginAllowThreads();
4908 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4909
4910 wxPyEndAllowThreads(__tstate);
4911 if (PyErr_Occurred()) SWIG_fail;
4912 }
4913 {
4914 #if wxUSE_UNICODE
4915 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4916 #else
4917 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4918 #endif
4919 }
4920 {
4921 if (temp1)
4922 delete arg1;
4923 }
4924 {
4925 if (temp2)
4926 delete arg2;
4927 }
4928 return resultobj;
4929 fail:
4930 {
4931 if (temp1)
4932 delete arg1;
4933 }
4934 {
4935 if (temp2)
4936 delete arg2;
4937 }
4938 return NULL;
4939 }
4940
4941
4942 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4943 PyObject *resultobj;
4944 wxString *arg1 = 0 ;
4945 wxString const &arg2_defvalue = wxPyEmptyString ;
4946 wxString *arg2 = (wxString *) &arg2_defvalue ;
4947 wxString const &arg3_defvalue = wxPyEmptyString ;
4948 wxString *arg3 = (wxString *) &arg3_defvalue ;
4949 wxWindow *arg4 = (wxWindow *) NULL ;
4950 int arg5 = (int) -1 ;
4951 int arg6 = (int) -1 ;
4952 bool arg7 = (bool) true ;
4953 wxString result;
4954 bool temp1 = false ;
4955 bool temp2 = false ;
4956 bool temp3 = false ;
4957 PyObject * obj0 = 0 ;
4958 PyObject * obj1 = 0 ;
4959 PyObject * obj2 = 0 ;
4960 PyObject * obj3 = 0 ;
4961 PyObject * obj4 = 0 ;
4962 PyObject * obj5 = 0 ;
4963 PyObject * obj6 = 0 ;
4964 char *kwnames[] = {
4965 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4966 };
4967
4968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4969 {
4970 arg1 = wxString_in_helper(obj0);
4971 if (arg1 == NULL) SWIG_fail;
4972 temp1 = true;
4973 }
4974 if (obj1) {
4975 {
4976 arg2 = wxString_in_helper(obj1);
4977 if (arg2 == NULL) SWIG_fail;
4978 temp2 = true;
4979 }
4980 }
4981 if (obj2) {
4982 {
4983 arg3 = wxString_in_helper(obj2);
4984 if (arg3 == NULL) SWIG_fail;
4985 temp3 = true;
4986 }
4987 }
4988 if (obj3) {
4989 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4990 if (SWIG_arg_fail(4)) SWIG_fail;
4991 }
4992 if (obj4) {
4993 {
4994 arg5 = (int)(SWIG_As_int(obj4));
4995 if (SWIG_arg_fail(5)) SWIG_fail;
4996 }
4997 }
4998 if (obj5) {
4999 {
5000 arg6 = (int)(SWIG_As_int(obj5));
5001 if (SWIG_arg_fail(6)) SWIG_fail;
5002 }
5003 }
5004 if (obj6) {
5005 {
5006 arg7 = (bool)(SWIG_As_bool(obj6));
5007 if (SWIG_arg_fail(7)) SWIG_fail;
5008 }
5009 }
5010 {
5011 if (!wxPyCheckForApp()) SWIG_fail;
5012 PyThreadState* __tstate = wxPyBeginAllowThreads();
5013 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5014
5015 wxPyEndAllowThreads(__tstate);
5016 if (PyErr_Occurred()) SWIG_fail;
5017 }
5018 {
5019 #if wxUSE_UNICODE
5020 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5021 #else
5022 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5023 #endif
5024 }
5025 {
5026 if (temp1)
5027 delete arg1;
5028 }
5029 {
5030 if (temp2)
5031 delete arg2;
5032 }
5033 {
5034 if (temp3)
5035 delete arg3;
5036 }
5037 return resultobj;
5038 fail:
5039 {
5040 if (temp1)
5041 delete arg1;
5042 }
5043 {
5044 if (temp2)
5045 delete arg2;
5046 }
5047 {
5048 if (temp3)
5049 delete arg3;
5050 }
5051 return NULL;
5052 }
5053
5054
5055 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5056 PyObject *resultobj;
5057 wxString *arg1 = 0 ;
5058 wxString const &arg2_defvalue = wxPyEmptyString ;
5059 wxString *arg2 = (wxString *) &arg2_defvalue ;
5060 wxString const &arg3_defvalue = wxPyEmptyString ;
5061 wxString *arg3 = (wxString *) &arg3_defvalue ;
5062 wxWindow *arg4 = (wxWindow *) NULL ;
5063 wxString result;
5064 bool temp1 = false ;
5065 bool temp2 = false ;
5066 bool temp3 = false ;
5067 PyObject * obj0 = 0 ;
5068 PyObject * obj1 = 0 ;
5069 PyObject * obj2 = 0 ;
5070 PyObject * obj3 = 0 ;
5071 char *kwnames[] = {
5072 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5073 };
5074
5075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5076 {
5077 arg1 = wxString_in_helper(obj0);
5078 if (arg1 == NULL) SWIG_fail;
5079 temp1 = true;
5080 }
5081 if (obj1) {
5082 {
5083 arg2 = wxString_in_helper(obj1);
5084 if (arg2 == NULL) SWIG_fail;
5085 temp2 = true;
5086 }
5087 }
5088 if (obj2) {
5089 {
5090 arg3 = wxString_in_helper(obj2);
5091 if (arg3 == NULL) SWIG_fail;
5092 temp3 = true;
5093 }
5094 }
5095 if (obj3) {
5096 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5097 if (SWIG_arg_fail(4)) SWIG_fail;
5098 }
5099 {
5100 if (!wxPyCheckForApp()) SWIG_fail;
5101 PyThreadState* __tstate = wxPyBeginAllowThreads();
5102 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5103
5104 wxPyEndAllowThreads(__tstate);
5105 if (PyErr_Occurred()) SWIG_fail;
5106 }
5107 {
5108 #if wxUSE_UNICODE
5109 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5110 #else
5111 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5112 #endif
5113 }
5114 {
5115 if (temp1)
5116 delete arg1;
5117 }
5118 {
5119 if (temp2)
5120 delete arg2;
5121 }
5122 {
5123 if (temp3)
5124 delete arg3;
5125 }
5126 return resultobj;
5127 fail:
5128 {
5129 if (temp1)
5130 delete arg1;
5131 }
5132 {
5133 if (temp2)
5134 delete arg2;
5135 }
5136 {
5137 if (temp3)
5138 delete arg3;
5139 }
5140 return NULL;
5141 }
5142
5143
5144 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5145 PyObject *resultobj;
5146 wxString *arg1 = 0 ;
5147 wxString *arg2 = 0 ;
5148 int arg3 ;
5149 wxString *arg4 = (wxString *) 0 ;
5150 wxWindow *arg5 = (wxWindow *) NULL ;
5151 int arg6 = (int) -1 ;
5152 int arg7 = (int) -1 ;
5153 bool arg8 = (bool) true ;
5154 int arg9 = (int) 150 ;
5155 int arg10 = (int) 200 ;
5156 wxString result;
5157 bool temp1 = false ;
5158 bool temp2 = false ;
5159 PyObject * obj0 = 0 ;
5160 PyObject * obj1 = 0 ;
5161 PyObject * obj2 = 0 ;
5162 PyObject * obj3 = 0 ;
5163 PyObject * obj4 = 0 ;
5164 PyObject * obj5 = 0 ;
5165 PyObject * obj6 = 0 ;
5166 PyObject * obj7 = 0 ;
5167 PyObject * obj8 = 0 ;
5168 char *kwnames[] = {
5169 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5170 };
5171
5172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5173 {
5174 arg1 = wxString_in_helper(obj0);
5175 if (arg1 == NULL) SWIG_fail;
5176 temp1 = true;
5177 }
5178 {
5179 arg2 = wxString_in_helper(obj1);
5180 if (arg2 == NULL) SWIG_fail;
5181 temp2 = true;
5182 }
5183 {
5184 arg3 = PyList_Size(obj2);
5185 arg4 = wxString_LIST_helper(obj2);
5186 if (arg4 == NULL) SWIG_fail;
5187 }
5188 if (obj3) {
5189 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5190 if (SWIG_arg_fail(5)) SWIG_fail;
5191 }
5192 if (obj4) {
5193 {
5194 arg6 = (int)(SWIG_As_int(obj4));
5195 if (SWIG_arg_fail(6)) SWIG_fail;
5196 }
5197 }
5198 if (obj5) {
5199 {
5200 arg7 = (int)(SWIG_As_int(obj5));
5201 if (SWIG_arg_fail(7)) SWIG_fail;
5202 }
5203 }
5204 if (obj6) {
5205 {
5206 arg8 = (bool)(SWIG_As_bool(obj6));
5207 if (SWIG_arg_fail(8)) SWIG_fail;
5208 }
5209 }
5210 if (obj7) {
5211 {
5212 arg9 = (int)(SWIG_As_int(obj7));
5213 if (SWIG_arg_fail(9)) SWIG_fail;
5214 }
5215 }
5216 if (obj8) {
5217 {
5218 arg10 = (int)(SWIG_As_int(obj8));
5219 if (SWIG_arg_fail(10)) SWIG_fail;
5220 }
5221 }
5222 {
5223 if (!wxPyCheckForApp()) SWIG_fail;
5224 PyThreadState* __tstate = wxPyBeginAllowThreads();
5225 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5226
5227 wxPyEndAllowThreads(__tstate);
5228 if (PyErr_Occurred()) SWIG_fail;
5229 }
5230 {
5231 #if wxUSE_UNICODE
5232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5233 #else
5234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5235 #endif
5236 }
5237 {
5238 if (temp1)
5239 delete arg1;
5240 }
5241 {
5242 if (temp2)
5243 delete arg2;
5244 }
5245 {
5246 if (arg4) delete [] arg4;
5247 }
5248 return resultobj;
5249 fail:
5250 {
5251 if (temp1)
5252 delete arg1;
5253 }
5254 {
5255 if (temp2)
5256 delete arg2;
5257 }
5258 {
5259 if (arg4) delete [] arg4;
5260 }
5261 return NULL;
5262 }
5263
5264
5265 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5266 PyObject *resultobj;
5267 wxString *arg1 = 0 ;
5268 wxString *arg2 = 0 ;
5269 int arg3 ;
5270 wxString *arg4 = (wxString *) 0 ;
5271 wxWindow *arg5 = (wxWindow *) NULL ;
5272 int arg6 = (int) -1 ;
5273 int arg7 = (int) -1 ;
5274 bool arg8 = (bool) true ;
5275 int arg9 = (int) 150 ;
5276 int arg10 = (int) 200 ;
5277 int result;
5278 bool temp1 = false ;
5279 bool temp2 = false ;
5280 PyObject * obj0 = 0 ;
5281 PyObject * obj1 = 0 ;
5282 PyObject * obj2 = 0 ;
5283 PyObject * obj3 = 0 ;
5284 PyObject * obj4 = 0 ;
5285 PyObject * obj5 = 0 ;
5286 PyObject * obj6 = 0 ;
5287 PyObject * obj7 = 0 ;
5288 PyObject * obj8 = 0 ;
5289 char *kwnames[] = {
5290 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5291 };
5292
5293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5294 {
5295 arg1 = wxString_in_helper(obj0);
5296 if (arg1 == NULL) SWIG_fail;
5297 temp1 = true;
5298 }
5299 {
5300 arg2 = wxString_in_helper(obj1);
5301 if (arg2 == NULL) SWIG_fail;
5302 temp2 = true;
5303 }
5304 {
5305 arg3 = PyList_Size(obj2);
5306 arg4 = wxString_LIST_helper(obj2);
5307 if (arg4 == NULL) SWIG_fail;
5308 }
5309 if (obj3) {
5310 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5311 if (SWIG_arg_fail(5)) SWIG_fail;
5312 }
5313 if (obj4) {
5314 {
5315 arg6 = (int)(SWIG_As_int(obj4));
5316 if (SWIG_arg_fail(6)) SWIG_fail;
5317 }
5318 }
5319 if (obj5) {
5320 {
5321 arg7 = (int)(SWIG_As_int(obj5));
5322 if (SWIG_arg_fail(7)) SWIG_fail;
5323 }
5324 }
5325 if (obj6) {
5326 {
5327 arg8 = (bool)(SWIG_As_bool(obj6));
5328 if (SWIG_arg_fail(8)) SWIG_fail;
5329 }
5330 }
5331 if (obj7) {
5332 {
5333 arg9 = (int)(SWIG_As_int(obj7));
5334 if (SWIG_arg_fail(9)) SWIG_fail;
5335 }
5336 }
5337 if (obj8) {
5338 {
5339 arg10 = (int)(SWIG_As_int(obj8));
5340 if (SWIG_arg_fail(10)) SWIG_fail;
5341 }
5342 }
5343 {
5344 if (!wxPyCheckForApp()) SWIG_fail;
5345 PyThreadState* __tstate = wxPyBeginAllowThreads();
5346 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5347
5348 wxPyEndAllowThreads(__tstate);
5349 if (PyErr_Occurred()) SWIG_fail;
5350 }
5351 {
5352 resultobj = SWIG_From_int((int)(result));
5353 }
5354 {
5355 if (temp1)
5356 delete arg1;
5357 }
5358 {
5359 if (temp2)
5360 delete arg2;
5361 }
5362 {
5363 if (arg4) delete [] arg4;
5364 }
5365 return resultobj;
5366 fail:
5367 {
5368 if (temp1)
5369 delete arg1;
5370 }
5371 {
5372 if (temp2)
5373 delete arg2;
5374 }
5375 {
5376 if (arg4) delete [] arg4;
5377 }
5378 return NULL;
5379 }
5380
5381
5382 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5383 PyObject *resultobj;
5384 wxString *arg1 = 0 ;
5385 wxString const &arg2_defvalue = wxPyEmptyString ;
5386 wxString *arg2 = (wxString *) &arg2_defvalue ;
5387 int arg3 = (int) wxOK|wxCENTRE ;
5388 wxWindow *arg4 = (wxWindow *) NULL ;
5389 int arg5 = (int) -1 ;
5390 int arg6 = (int) -1 ;
5391 int result;
5392 bool temp1 = false ;
5393 bool temp2 = false ;
5394 PyObject * obj0 = 0 ;
5395 PyObject * obj1 = 0 ;
5396 PyObject * obj2 = 0 ;
5397 PyObject * obj3 = 0 ;
5398 PyObject * obj4 = 0 ;
5399 PyObject * obj5 = 0 ;
5400 char *kwnames[] = {
5401 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5402 };
5403
5404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5405 {
5406 arg1 = wxString_in_helper(obj0);
5407 if (arg1 == NULL) SWIG_fail;
5408 temp1 = true;
5409 }
5410 if (obj1) {
5411 {
5412 arg2 = wxString_in_helper(obj1);
5413 if (arg2 == NULL) SWIG_fail;
5414 temp2 = true;
5415 }
5416 }
5417 if (obj2) {
5418 {
5419 arg3 = (int)(SWIG_As_int(obj2));
5420 if (SWIG_arg_fail(3)) SWIG_fail;
5421 }
5422 }
5423 if (obj3) {
5424 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5425 if (SWIG_arg_fail(4)) SWIG_fail;
5426 }
5427 if (obj4) {
5428 {
5429 arg5 = (int)(SWIG_As_int(obj4));
5430 if (SWIG_arg_fail(5)) SWIG_fail;
5431 }
5432 }
5433 if (obj5) {
5434 {
5435 arg6 = (int)(SWIG_As_int(obj5));
5436 if (SWIG_arg_fail(6)) SWIG_fail;
5437 }
5438 }
5439 {
5440 if (!wxPyCheckForApp()) SWIG_fail;
5441 PyThreadState* __tstate = wxPyBeginAllowThreads();
5442 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5443
5444 wxPyEndAllowThreads(__tstate);
5445 if (PyErr_Occurred()) SWIG_fail;
5446 }
5447 {
5448 resultobj = SWIG_From_int((int)(result));
5449 }
5450 {
5451 if (temp1)
5452 delete arg1;
5453 }
5454 {
5455 if (temp2)
5456 delete arg2;
5457 }
5458 return resultobj;
5459 fail:
5460 {
5461 if (temp1)
5462 delete arg1;
5463 }
5464 {
5465 if (temp2)
5466 delete arg2;
5467 }
5468 return NULL;
5469 }
5470
5471
5472 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5473 PyObject *resultobj;
5474 wxString *arg1 = 0 ;
5475 wxString *arg2 = 0 ;
5476 wxString *arg3 = 0 ;
5477 long arg4 ;
5478 long arg5 = (long) 0 ;
5479 long arg6 = (long) 100 ;
5480 wxWindow *arg7 = (wxWindow *) NULL ;
5481 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5482 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5483 long result;
5484 bool temp1 = false ;
5485 bool temp2 = false ;
5486 bool temp3 = false ;
5487 wxPoint temp8 ;
5488 PyObject * obj0 = 0 ;
5489 PyObject * obj1 = 0 ;
5490 PyObject * obj2 = 0 ;
5491 PyObject * obj3 = 0 ;
5492 PyObject * obj4 = 0 ;
5493 PyObject * obj5 = 0 ;
5494 PyObject * obj6 = 0 ;
5495 PyObject * obj7 = 0 ;
5496 char *kwnames[] = {
5497 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5498 };
5499
5500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5501 {
5502 arg1 = wxString_in_helper(obj0);
5503 if (arg1 == NULL) SWIG_fail;
5504 temp1 = true;
5505 }
5506 {
5507 arg2 = wxString_in_helper(obj1);
5508 if (arg2 == NULL) SWIG_fail;
5509 temp2 = true;
5510 }
5511 {
5512 arg3 = wxString_in_helper(obj2);
5513 if (arg3 == NULL) SWIG_fail;
5514 temp3 = true;
5515 }
5516 {
5517 arg4 = (long)(SWIG_As_long(obj3));
5518 if (SWIG_arg_fail(4)) SWIG_fail;
5519 }
5520 if (obj4) {
5521 {
5522 arg5 = (long)(SWIG_As_long(obj4));
5523 if (SWIG_arg_fail(5)) SWIG_fail;
5524 }
5525 }
5526 if (obj5) {
5527 {
5528 arg6 = (long)(SWIG_As_long(obj5));
5529 if (SWIG_arg_fail(6)) SWIG_fail;
5530 }
5531 }
5532 if (obj6) {
5533 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5534 if (SWIG_arg_fail(7)) SWIG_fail;
5535 }
5536 if (obj7) {
5537 {
5538 arg8 = &temp8;
5539 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5540 }
5541 }
5542 {
5543 if (!wxPyCheckForApp()) SWIG_fail;
5544 PyThreadState* __tstate = wxPyBeginAllowThreads();
5545 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5546
5547 wxPyEndAllowThreads(__tstate);
5548 if (PyErr_Occurred()) SWIG_fail;
5549 }
5550 {
5551 resultobj = SWIG_From_long((long)(result));
5552 }
5553 {
5554 if (temp1)
5555 delete arg1;
5556 }
5557 {
5558 if (temp2)
5559 delete arg2;
5560 }
5561 {
5562 if (temp3)
5563 delete arg3;
5564 }
5565 return resultobj;
5566 fail:
5567 {
5568 if (temp1)
5569 delete arg1;
5570 }
5571 {
5572 if (temp2)
5573 delete arg2;
5574 }
5575 {
5576 if (temp3)
5577 delete arg3;
5578 }
5579 return NULL;
5580 }
5581
5582
5583 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5584 PyObject *resultobj;
5585 bool result;
5586 char *kwnames[] = {
5587 NULL
5588 };
5589
5590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5591 {
5592 if (!wxPyCheckForApp()) SWIG_fail;
5593 PyThreadState* __tstate = wxPyBeginAllowThreads();
5594 result = (bool)wxColourDisplay();
5595
5596 wxPyEndAllowThreads(__tstate);
5597 if (PyErr_Occurred()) SWIG_fail;
5598 }
5599 {
5600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5601 }
5602 return resultobj;
5603 fail:
5604 return NULL;
5605 }
5606
5607
5608 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5609 PyObject *resultobj;
5610 int result;
5611 char *kwnames[] = {
5612 NULL
5613 };
5614
5615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5616 {
5617 if (!wxPyCheckForApp()) SWIG_fail;
5618 PyThreadState* __tstate = wxPyBeginAllowThreads();
5619 result = (int)wxDisplayDepth();
5620
5621 wxPyEndAllowThreads(__tstate);
5622 if (PyErr_Occurred()) SWIG_fail;
5623 }
5624 {
5625 resultobj = SWIG_From_int((int)(result));
5626 }
5627 return resultobj;
5628 fail:
5629 return NULL;
5630 }
5631
5632
5633 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5634 PyObject *resultobj;
5635 int result;
5636 char *kwnames[] = {
5637 NULL
5638 };
5639
5640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5641 {
5642 if (!wxPyCheckForApp()) SWIG_fail;
5643 PyThreadState* __tstate = wxPyBeginAllowThreads();
5644 result = (int)wxGetDisplayDepth();
5645
5646 wxPyEndAllowThreads(__tstate);
5647 if (PyErr_Occurred()) SWIG_fail;
5648 }
5649 {
5650 resultobj = SWIG_From_int((int)(result));
5651 }
5652 return resultobj;
5653 fail:
5654 return NULL;
5655 }
5656
5657
5658 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5659 PyObject *resultobj;
5660 int *arg1 = (int *) 0 ;
5661 int *arg2 = (int *) 0 ;
5662 int temp1 ;
5663 int res1 = 0 ;
5664 int temp2 ;
5665 int res2 = 0 ;
5666 char *kwnames[] = {
5667 NULL
5668 };
5669
5670 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5671 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5673 {
5674 if (!wxPyCheckForApp()) SWIG_fail;
5675 PyThreadState* __tstate = wxPyBeginAllowThreads();
5676 wxDisplaySize(arg1,arg2);
5677
5678 wxPyEndAllowThreads(__tstate);
5679 if (PyErr_Occurred()) SWIG_fail;
5680 }
5681 Py_INCREF(Py_None); resultobj = Py_None;
5682 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5683 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5684 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5685 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5686 return resultobj;
5687 fail:
5688 return NULL;
5689 }
5690
5691
5692 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5693 PyObject *resultobj;
5694 wxSize result;
5695 char *kwnames[] = {
5696 NULL
5697 };
5698
5699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5700 {
5701 if (!wxPyCheckForApp()) SWIG_fail;
5702 PyThreadState* __tstate = wxPyBeginAllowThreads();
5703 result = wxGetDisplaySize();
5704
5705 wxPyEndAllowThreads(__tstate);
5706 if (PyErr_Occurred()) SWIG_fail;
5707 }
5708 {
5709 wxSize * resultptr;
5710 resultptr = new wxSize((wxSize &)(result));
5711 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5712 }
5713 return resultobj;
5714 fail:
5715 return NULL;
5716 }
5717
5718
5719 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5720 PyObject *resultobj;
5721 int *arg1 = (int *) 0 ;
5722 int *arg2 = (int *) 0 ;
5723 int temp1 ;
5724 int res1 = 0 ;
5725 int temp2 ;
5726 int res2 = 0 ;
5727 char *kwnames[] = {
5728 NULL
5729 };
5730
5731 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5732 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5734 {
5735 if (!wxPyCheckForApp()) SWIG_fail;
5736 PyThreadState* __tstate = wxPyBeginAllowThreads();
5737 wxDisplaySizeMM(arg1,arg2);
5738
5739 wxPyEndAllowThreads(__tstate);
5740 if (PyErr_Occurred()) SWIG_fail;
5741 }
5742 Py_INCREF(Py_None); resultobj = Py_None;
5743 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5744 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5745 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5746 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5754 PyObject *resultobj;
5755 wxSize result;
5756 char *kwnames[] = {
5757 NULL
5758 };
5759
5760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5761 {
5762 if (!wxPyCheckForApp()) SWIG_fail;
5763 PyThreadState* __tstate = wxPyBeginAllowThreads();
5764 result = wxGetDisplaySizeMM();
5765
5766 wxPyEndAllowThreads(__tstate);
5767 if (PyErr_Occurred()) SWIG_fail;
5768 }
5769 {
5770 wxSize * resultptr;
5771 resultptr = new wxSize((wxSize &)(result));
5772 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5773 }
5774 return resultobj;
5775 fail:
5776 return NULL;
5777 }
5778
5779
5780 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5781 PyObject *resultobj;
5782 int *arg1 = (int *) 0 ;
5783 int *arg2 = (int *) 0 ;
5784 int *arg3 = (int *) 0 ;
5785 int *arg4 = (int *) 0 ;
5786 int temp1 ;
5787 int res1 = 0 ;
5788 int temp2 ;
5789 int res2 = 0 ;
5790 int temp3 ;
5791 int res3 = 0 ;
5792 int temp4 ;
5793 int res4 = 0 ;
5794 char *kwnames[] = {
5795 NULL
5796 };
5797
5798 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5799 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5800 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5801 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5803 {
5804 if (!wxPyCheckForApp()) SWIG_fail;
5805 PyThreadState* __tstate = wxPyBeginAllowThreads();
5806 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5807
5808 wxPyEndAllowThreads(__tstate);
5809 if (PyErr_Occurred()) SWIG_fail;
5810 }
5811 Py_INCREF(Py_None); resultobj = Py_None;
5812 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5813 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5814 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5815 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5816 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5817 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5818 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5819 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5820 return resultobj;
5821 fail:
5822 return NULL;
5823 }
5824
5825
5826 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5827 PyObject *resultobj;
5828 wxRect result;
5829 char *kwnames[] = {
5830 NULL
5831 };
5832
5833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5834 {
5835 if (!wxPyCheckForApp()) SWIG_fail;
5836 PyThreadState* __tstate = wxPyBeginAllowThreads();
5837 result = wxGetClientDisplayRect();
5838
5839 wxPyEndAllowThreads(__tstate);
5840 if (PyErr_Occurred()) SWIG_fail;
5841 }
5842 {
5843 wxRect * resultptr;
5844 resultptr = new wxRect((wxRect &)(result));
5845 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5846 }
5847 return resultobj;
5848 fail:
5849 return NULL;
5850 }
5851
5852
5853 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5854 PyObject *resultobj;
5855 wxCursor *arg1 = 0 ;
5856 PyObject * obj0 = 0 ;
5857 char *kwnames[] = {
5858 (char *) "cursor", NULL
5859 };
5860
5861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5862 {
5863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5864 if (SWIG_arg_fail(1)) SWIG_fail;
5865 if (arg1 == NULL) {
5866 SWIG_null_ref("wxCursor");
5867 }
5868 if (SWIG_arg_fail(1)) SWIG_fail;
5869 }
5870 {
5871 if (!wxPyCheckForApp()) SWIG_fail;
5872 PyThreadState* __tstate = wxPyBeginAllowThreads();
5873 wxSetCursor(*arg1);
5874
5875 wxPyEndAllowThreads(__tstate);
5876 if (PyErr_Occurred()) SWIG_fail;
5877 }
5878 Py_INCREF(Py_None); resultobj = Py_None;
5879 return resultobj;
5880 fail:
5881 return NULL;
5882 }
5883
5884
5885 static PyObject *_wrap_GetXDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5886 PyObject *resultobj;
5887 void *result;
5888 char *kwnames[] = {
5889 NULL
5890 };
5891
5892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetXDisplay",kwnames)) goto fail;
5893 {
5894 if (!wxPyCheckForApp()) SWIG_fail;
5895 PyThreadState* __tstate = wxPyBeginAllowThreads();
5896 result = (void *)wxGetXDisplay();
5897
5898 wxPyEndAllowThreads(__tstate);
5899 if (PyErr_Occurred()) SWIG_fail;
5900 }
5901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
5902 return resultobj;
5903 fail:
5904 return NULL;
5905 }
5906
5907
5908 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5909 PyObject *resultobj;
5910 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5911 PyObject * obj0 = 0 ;
5912 char *kwnames[] = {
5913 (char *) "cursor", NULL
5914 };
5915
5916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5917 if (obj0) {
5918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5919 if (SWIG_arg_fail(1)) SWIG_fail;
5920 }
5921 {
5922 if (!wxPyCheckForApp()) SWIG_fail;
5923 PyThreadState* __tstate = wxPyBeginAllowThreads();
5924 wxBeginBusyCursor(arg1);
5925
5926 wxPyEndAllowThreads(__tstate);
5927 if (PyErr_Occurred()) SWIG_fail;
5928 }
5929 Py_INCREF(Py_None); resultobj = Py_None;
5930 return resultobj;
5931 fail:
5932 return NULL;
5933 }
5934
5935
5936 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5937 PyObject *resultobj;
5938 wxWindow *result;
5939 char *kwnames[] = {
5940 NULL
5941 };
5942
5943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5944 {
5945 if (!wxPyCheckForApp()) SWIG_fail;
5946 PyThreadState* __tstate = wxPyBeginAllowThreads();
5947 result = (wxWindow *)wxGetActiveWindow();
5948
5949 wxPyEndAllowThreads(__tstate);
5950 if (PyErr_Occurred()) SWIG_fail;
5951 }
5952 {
5953 resultobj = wxPyMake_wxObject(result, 0);
5954 }
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj;
5963 wxPoint *arg1 = 0 ;
5964 wxWindow *result;
5965 wxPoint temp1 ;
5966 PyObject * obj0 = 0 ;
5967 char *kwnames[] = {
5968 (char *) "pt", NULL
5969 };
5970
5971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5972 {
5973 arg1 = &temp1;
5974 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5975 }
5976 {
5977 if (!wxPyCheckForApp()) SWIG_fail;
5978 PyThreadState* __tstate = wxPyBeginAllowThreads();
5979 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5980
5981 wxPyEndAllowThreads(__tstate);
5982 if (PyErr_Occurred()) SWIG_fail;
5983 }
5984 {
5985 resultobj = wxPyMake_wxObject(result, 0);
5986 }
5987 return resultobj;
5988 fail:
5989 return NULL;
5990 }
5991
5992
5993 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5994 PyObject *resultobj;
5995 wxPoint *arg1 = 0 ;
5996 wxWindow *result;
5997 wxPoint temp1 ;
5998 PyObject * obj0 = 0 ;
5999 char *kwnames[] = {
6000 (char *) "pt", NULL
6001 };
6002
6003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
6004 {
6005 arg1 = &temp1;
6006 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6007 }
6008 {
6009 if (!wxPyCheckForApp()) SWIG_fail;
6010 PyThreadState* __tstate = wxPyBeginAllowThreads();
6011 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6012
6013 wxPyEndAllowThreads(__tstate);
6014 if (PyErr_Occurred()) SWIG_fail;
6015 }
6016 {
6017 resultobj = wxPyMake_wxObject(result, 0);
6018 }
6019 return resultobj;
6020 fail:
6021 return NULL;
6022 }
6023
6024
6025 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
6026 PyObject *resultobj;
6027 wxWindow *arg1 = (wxWindow *) 0 ;
6028 wxWindow *result;
6029 PyObject * obj0 = 0 ;
6030 char *kwnames[] = {
6031 (char *) "win", NULL
6032 };
6033
6034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
6035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6036 if (SWIG_arg_fail(1)) SWIG_fail;
6037 {
6038 if (!wxPyCheckForApp()) SWIG_fail;
6039 PyThreadState* __tstate = wxPyBeginAllowThreads();
6040 result = (wxWindow *)wxGetTopLevelParent(arg1);
6041
6042 wxPyEndAllowThreads(__tstate);
6043 if (PyErr_Occurred()) SWIG_fail;
6044 }
6045 {
6046 resultobj = wxPyMake_wxObject(result, 0);
6047 }
6048 return resultobj;
6049 fail:
6050 return NULL;
6051 }
6052
6053
6054 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6055 PyObject *resultobj;
6056 wxString *arg1 = 0 ;
6057 bool result;
6058 bool temp1 = false ;
6059 PyObject * obj0 = 0 ;
6060 char *kwnames[] = {
6061 (char *) "url", NULL
6062 };
6063
6064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6065 {
6066 arg1 = wxString_in_helper(obj0);
6067 if (arg1 == NULL) SWIG_fail;
6068 temp1 = true;
6069 }
6070 {
6071 PyThreadState* __tstate = wxPyBeginAllowThreads();
6072 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6073
6074 wxPyEndAllowThreads(__tstate);
6075 if (PyErr_Occurred()) SWIG_fail;
6076 }
6077 {
6078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6079 }
6080 {
6081 if (temp1)
6082 delete arg1;
6083 }
6084 return resultobj;
6085 fail:
6086 {
6087 if (temp1)
6088 delete arg1;
6089 }
6090 return NULL;
6091 }
6092
6093
6094 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6095 PyObject *resultobj;
6096 wxKeyCode arg1 ;
6097 bool result;
6098 PyObject * obj0 = 0 ;
6099 char *kwnames[] = {
6100 (char *) "key", NULL
6101 };
6102
6103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6104 {
6105 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6106 if (SWIG_arg_fail(1)) SWIG_fail;
6107 }
6108 {
6109 if (!wxPyCheckForApp()) SWIG_fail;
6110 PyThreadState* __tstate = wxPyBeginAllowThreads();
6111 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6112
6113 wxPyEndAllowThreads(__tstate);
6114 if (PyErr_Occurred()) SWIG_fail;
6115 }
6116 {
6117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6118 }
6119 return resultobj;
6120 fail:
6121 return NULL;
6122 }
6123
6124
6125 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6126 PyObject *resultobj;
6127 char *kwnames[] = {
6128 NULL
6129 };
6130
6131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6132 {
6133 if (!wxPyCheckForApp()) SWIG_fail;
6134 PyThreadState* __tstate = wxPyBeginAllowThreads();
6135 wxWakeUpMainThread();
6136
6137 wxPyEndAllowThreads(__tstate);
6138 if (PyErr_Occurred()) SWIG_fail;
6139 }
6140 Py_INCREF(Py_None); resultobj = Py_None;
6141 return resultobj;
6142 fail:
6143 return NULL;
6144 }
6145
6146
6147 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6148 PyObject *resultobj;
6149 char *kwnames[] = {
6150 NULL
6151 };
6152
6153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6154 {
6155 if (!wxPyCheckForApp()) SWIG_fail;
6156 PyThreadState* __tstate = wxPyBeginAllowThreads();
6157 wxMutexGuiEnter();
6158
6159 wxPyEndAllowThreads(__tstate);
6160 if (PyErr_Occurred()) SWIG_fail;
6161 }
6162 Py_INCREF(Py_None); resultobj = Py_None;
6163 return resultobj;
6164 fail:
6165 return NULL;
6166 }
6167
6168
6169 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6170 PyObject *resultobj;
6171 char *kwnames[] = {
6172 NULL
6173 };
6174
6175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6176 {
6177 if (!wxPyCheckForApp()) SWIG_fail;
6178 PyThreadState* __tstate = wxPyBeginAllowThreads();
6179 wxMutexGuiLeave();
6180
6181 wxPyEndAllowThreads(__tstate);
6182 if (PyErr_Occurred()) SWIG_fail;
6183 }
6184 Py_INCREF(Py_None); resultobj = Py_None;
6185 return resultobj;
6186 fail:
6187 return NULL;
6188 }
6189
6190
6191 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6192 PyObject *resultobj;
6193 wxMutexGuiLocker *result;
6194 char *kwnames[] = {
6195 NULL
6196 };
6197
6198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6199 {
6200 if (!wxPyCheckForApp()) SWIG_fail;
6201 PyThreadState* __tstate = wxPyBeginAllowThreads();
6202 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6203
6204 wxPyEndAllowThreads(__tstate);
6205 if (PyErr_Occurred()) SWIG_fail;
6206 }
6207 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6208 return resultobj;
6209 fail:
6210 return NULL;
6211 }
6212
6213
6214 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6215 PyObject *resultobj;
6216 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6217 PyObject * obj0 = 0 ;
6218 char *kwnames[] = {
6219 (char *) "self", NULL
6220 };
6221
6222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6224 if (SWIG_arg_fail(1)) SWIG_fail;
6225 {
6226 PyThreadState* __tstate = wxPyBeginAllowThreads();
6227 delete arg1;
6228
6229 wxPyEndAllowThreads(__tstate);
6230 if (PyErr_Occurred()) SWIG_fail;
6231 }
6232 Py_INCREF(Py_None); resultobj = Py_None;
6233 return resultobj;
6234 fail:
6235 return NULL;
6236 }
6237
6238
6239 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6240 PyObject *obj;
6241 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6242 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6243 Py_INCREF(obj);
6244 return Py_BuildValue((char *)"");
6245 }
6246 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6247 PyObject *resultobj;
6248 bool result;
6249 char *kwnames[] = {
6250 NULL
6251 };
6252
6253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6254 {
6255 PyThreadState* __tstate = wxPyBeginAllowThreads();
6256 result = (bool)wxThread_IsMain();
6257
6258 wxPyEndAllowThreads(__tstate);
6259 if (PyErr_Occurred()) SWIG_fail;
6260 }
6261 {
6262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6263 }
6264 return resultobj;
6265 fail:
6266 return NULL;
6267 }
6268
6269
6270 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6271 PyObject *resultobj;
6272 wxString *arg1 = 0 ;
6273 wxToolTip *result;
6274 bool temp1 = false ;
6275 PyObject * obj0 = 0 ;
6276 char *kwnames[] = {
6277 (char *) "tip", NULL
6278 };
6279
6280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6281 {
6282 arg1 = wxString_in_helper(obj0);
6283 if (arg1 == NULL) SWIG_fail;
6284 temp1 = true;
6285 }
6286 {
6287 if (!wxPyCheckForApp()) SWIG_fail;
6288 PyThreadState* __tstate = wxPyBeginAllowThreads();
6289 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6290
6291 wxPyEndAllowThreads(__tstate);
6292 if (PyErr_Occurred()) SWIG_fail;
6293 }
6294 {
6295 resultobj = wxPyMake_wxObject(result, 1);
6296 }
6297 {
6298 if (temp1)
6299 delete arg1;
6300 }
6301 return resultobj;
6302 fail:
6303 {
6304 if (temp1)
6305 delete arg1;
6306 }
6307 return NULL;
6308 }
6309
6310
6311 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6312 PyObject *resultobj;
6313 wxToolTip *arg1 = (wxToolTip *) 0 ;
6314 wxString *arg2 = 0 ;
6315 bool temp2 = false ;
6316 PyObject * obj0 = 0 ;
6317 PyObject * obj1 = 0 ;
6318 char *kwnames[] = {
6319 (char *) "self",(char *) "tip", NULL
6320 };
6321
6322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6324 if (SWIG_arg_fail(1)) SWIG_fail;
6325 {
6326 arg2 = wxString_in_helper(obj1);
6327 if (arg2 == NULL) SWIG_fail;
6328 temp2 = true;
6329 }
6330 {
6331 PyThreadState* __tstate = wxPyBeginAllowThreads();
6332 (arg1)->SetTip((wxString const &)*arg2);
6333
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 Py_INCREF(Py_None); resultobj = Py_None;
6338 {
6339 if (temp2)
6340 delete arg2;
6341 }
6342 return resultobj;
6343 fail:
6344 {
6345 if (temp2)
6346 delete arg2;
6347 }
6348 return NULL;
6349 }
6350
6351
6352 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6353 PyObject *resultobj;
6354 wxToolTip *arg1 = (wxToolTip *) 0 ;
6355 wxString result;
6356 PyObject * obj0 = 0 ;
6357 char *kwnames[] = {
6358 (char *) "self", NULL
6359 };
6360
6361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6363 if (SWIG_arg_fail(1)) SWIG_fail;
6364 {
6365 PyThreadState* __tstate = wxPyBeginAllowThreads();
6366 result = (arg1)->GetTip();
6367
6368 wxPyEndAllowThreads(__tstate);
6369 if (PyErr_Occurred()) SWIG_fail;
6370 }
6371 {
6372 #if wxUSE_UNICODE
6373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6374 #else
6375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6376 #endif
6377 }
6378 return resultobj;
6379 fail:
6380 return NULL;
6381 }
6382
6383
6384 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6385 PyObject *resultobj;
6386 wxToolTip *arg1 = (wxToolTip *) 0 ;
6387 wxWindow *result;
6388 PyObject * obj0 = 0 ;
6389 char *kwnames[] = {
6390 (char *) "self", NULL
6391 };
6392
6393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6395 if (SWIG_arg_fail(1)) SWIG_fail;
6396 {
6397 PyThreadState* __tstate = wxPyBeginAllowThreads();
6398 result = (wxWindow *)(arg1)->GetWindow();
6399
6400 wxPyEndAllowThreads(__tstate);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 {
6404 resultobj = wxPyMake_wxObject(result, 0);
6405 }
6406 return resultobj;
6407 fail:
6408 return NULL;
6409 }
6410
6411
6412 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6413 PyObject *resultobj;
6414 bool arg1 ;
6415 PyObject * obj0 = 0 ;
6416 char *kwnames[] = {
6417 (char *) "flag", NULL
6418 };
6419
6420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6421 {
6422 arg1 = (bool)(SWIG_As_bool(obj0));
6423 if (SWIG_arg_fail(1)) SWIG_fail;
6424 }
6425 {
6426 PyThreadState* __tstate = wxPyBeginAllowThreads();
6427 wxToolTip::Enable(arg1);
6428
6429 wxPyEndAllowThreads(__tstate);
6430 if (PyErr_Occurred()) SWIG_fail;
6431 }
6432 Py_INCREF(Py_None); resultobj = Py_None;
6433 return resultobj;
6434 fail:
6435 return NULL;
6436 }
6437
6438
6439 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6440 PyObject *resultobj;
6441 long arg1 ;
6442 PyObject * obj0 = 0 ;
6443 char *kwnames[] = {
6444 (char *) "milliseconds", NULL
6445 };
6446
6447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6448 {
6449 arg1 = (long)(SWIG_As_long(obj0));
6450 if (SWIG_arg_fail(1)) SWIG_fail;
6451 }
6452 {
6453 PyThreadState* __tstate = wxPyBeginAllowThreads();
6454 wxToolTip::SetDelay(arg1);
6455
6456 wxPyEndAllowThreads(__tstate);
6457 if (PyErr_Occurred()) SWIG_fail;
6458 }
6459 Py_INCREF(Py_None); resultobj = Py_None;
6460 return resultobj;
6461 fail:
6462 return NULL;
6463 }
6464
6465
6466 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6467 PyObject *obj;
6468 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6469 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6470 Py_INCREF(obj);
6471 return Py_BuildValue((char *)"");
6472 }
6473 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6474 PyObject *resultobj;
6475 wxWindow *arg1 = (wxWindow *) 0 ;
6476 wxSize *arg2 = 0 ;
6477 wxCaret *result;
6478 wxSize temp2 ;
6479 PyObject * obj0 = 0 ;
6480 PyObject * obj1 = 0 ;
6481 char *kwnames[] = {
6482 (char *) "window",(char *) "size", NULL
6483 };
6484
6485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6487 if (SWIG_arg_fail(1)) SWIG_fail;
6488 {
6489 arg2 = &temp2;
6490 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6491 }
6492 {
6493 if (!wxPyCheckForApp()) SWIG_fail;
6494 PyThreadState* __tstate = wxPyBeginAllowThreads();
6495 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6496
6497 wxPyEndAllowThreads(__tstate);
6498 if (PyErr_Occurred()) SWIG_fail;
6499 }
6500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6501 return resultobj;
6502 fail:
6503 return NULL;
6504 }
6505
6506
6507 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6508 PyObject *resultobj;
6509 wxCaret *arg1 = (wxCaret *) 0 ;
6510 PyObject * obj0 = 0 ;
6511 char *kwnames[] = {
6512 (char *) "self", NULL
6513 };
6514
6515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6517 if (SWIG_arg_fail(1)) SWIG_fail;
6518 {
6519 PyThreadState* __tstate = wxPyBeginAllowThreads();
6520 wxCaret_Destroy(arg1);
6521
6522 wxPyEndAllowThreads(__tstate);
6523 if (PyErr_Occurred()) SWIG_fail;
6524 }
6525 Py_INCREF(Py_None); resultobj = Py_None;
6526 return resultobj;
6527 fail:
6528 return NULL;
6529 }
6530
6531
6532 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6533 PyObject *resultobj;
6534 wxCaret *arg1 = (wxCaret *) 0 ;
6535 bool result;
6536 PyObject * obj0 = 0 ;
6537 char *kwnames[] = {
6538 (char *) "self", NULL
6539 };
6540
6541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6543 if (SWIG_arg_fail(1)) SWIG_fail;
6544 {
6545 PyThreadState* __tstate = wxPyBeginAllowThreads();
6546 result = (bool)(arg1)->IsOk();
6547
6548 wxPyEndAllowThreads(__tstate);
6549 if (PyErr_Occurred()) SWIG_fail;
6550 }
6551 {
6552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6553 }
6554 return resultobj;
6555 fail:
6556 return NULL;
6557 }
6558
6559
6560 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6561 PyObject *resultobj;
6562 wxCaret *arg1 = (wxCaret *) 0 ;
6563 bool result;
6564 PyObject * obj0 = 0 ;
6565 char *kwnames[] = {
6566 (char *) "self", NULL
6567 };
6568
6569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6571 if (SWIG_arg_fail(1)) SWIG_fail;
6572 {
6573 PyThreadState* __tstate = wxPyBeginAllowThreads();
6574 result = (bool)(arg1)->IsVisible();
6575
6576 wxPyEndAllowThreads(__tstate);
6577 if (PyErr_Occurred()) SWIG_fail;
6578 }
6579 {
6580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6581 }
6582 return resultobj;
6583 fail:
6584 return NULL;
6585 }
6586
6587
6588 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6589 PyObject *resultobj;
6590 wxCaret *arg1 = (wxCaret *) 0 ;
6591 wxPoint result;
6592 PyObject * obj0 = 0 ;
6593 char *kwnames[] = {
6594 (char *) "self", NULL
6595 };
6596
6597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
6602 result = (arg1)->GetPosition();
6603
6604 wxPyEndAllowThreads(__tstate);
6605 if (PyErr_Occurred()) SWIG_fail;
6606 }
6607 {
6608 wxPoint * resultptr;
6609 resultptr = new wxPoint((wxPoint &)(result));
6610 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6611 }
6612 return resultobj;
6613 fail:
6614 return NULL;
6615 }
6616
6617
6618 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6619 PyObject *resultobj;
6620 wxCaret *arg1 = (wxCaret *) 0 ;
6621 int *arg2 = (int *) 0 ;
6622 int *arg3 = (int *) 0 ;
6623 int temp2 ;
6624 int res2 = 0 ;
6625 int temp3 ;
6626 int res3 = 0 ;
6627 PyObject * obj0 = 0 ;
6628 char *kwnames[] = {
6629 (char *) "self", NULL
6630 };
6631
6632 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6633 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6636 if (SWIG_arg_fail(1)) SWIG_fail;
6637 {
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 (arg1)->GetPosition(arg2,arg3);
6640
6641 wxPyEndAllowThreads(__tstate);
6642 if (PyErr_Occurred()) SWIG_fail;
6643 }
6644 Py_INCREF(Py_None); resultobj = Py_None;
6645 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6646 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6647 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6648 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6649 return resultobj;
6650 fail:
6651 return NULL;
6652 }
6653
6654
6655 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6656 PyObject *resultobj;
6657 wxCaret *arg1 = (wxCaret *) 0 ;
6658 wxSize result;
6659 PyObject * obj0 = 0 ;
6660 char *kwnames[] = {
6661 (char *) "self", NULL
6662 };
6663
6664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) 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 {
6668 PyThreadState* __tstate = wxPyBeginAllowThreads();
6669 result = (arg1)->GetSize();
6670
6671 wxPyEndAllowThreads(__tstate);
6672 if (PyErr_Occurred()) SWIG_fail;
6673 }
6674 {
6675 wxSize * resultptr;
6676 resultptr = new wxSize((wxSize &)(result));
6677 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6678 }
6679 return resultobj;
6680 fail:
6681 return NULL;
6682 }
6683
6684
6685 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6686 PyObject *resultobj;
6687 wxCaret *arg1 = (wxCaret *) 0 ;
6688 int *arg2 = (int *) 0 ;
6689 int *arg3 = (int *) 0 ;
6690 int temp2 ;
6691 int res2 = 0 ;
6692 int temp3 ;
6693 int res3 = 0 ;
6694 PyObject * obj0 = 0 ;
6695 char *kwnames[] = {
6696 (char *) "self", NULL
6697 };
6698
6699 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6700 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6703 if (SWIG_arg_fail(1)) SWIG_fail;
6704 {
6705 PyThreadState* __tstate = wxPyBeginAllowThreads();
6706 (arg1)->GetSize(arg2,arg3);
6707
6708 wxPyEndAllowThreads(__tstate);
6709 if (PyErr_Occurred()) SWIG_fail;
6710 }
6711 Py_INCREF(Py_None); resultobj = Py_None;
6712 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6713 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6714 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6715 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6716 return resultobj;
6717 fail:
6718 return NULL;
6719 }
6720
6721
6722 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6723 PyObject *resultobj;
6724 wxCaret *arg1 = (wxCaret *) 0 ;
6725 wxWindow *result;
6726 PyObject * obj0 = 0 ;
6727 char *kwnames[] = {
6728 (char *) "self", NULL
6729 };
6730
6731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6733 if (SWIG_arg_fail(1)) SWIG_fail;
6734 {
6735 PyThreadState* __tstate = wxPyBeginAllowThreads();
6736 result = (wxWindow *)(arg1)->GetWindow();
6737
6738 wxPyEndAllowThreads(__tstate);
6739 if (PyErr_Occurred()) SWIG_fail;
6740 }
6741 {
6742 resultobj = wxPyMake_wxObject(result, 0);
6743 }
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6751 PyObject *resultobj;
6752 wxCaret *arg1 = (wxCaret *) 0 ;
6753 int arg2 ;
6754 int arg3 ;
6755 PyObject * obj0 = 0 ;
6756 PyObject * obj1 = 0 ;
6757 PyObject * obj2 = 0 ;
6758 char *kwnames[] = {
6759 (char *) "self",(char *) "x",(char *) "y", NULL
6760 };
6761
6762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6764 if (SWIG_arg_fail(1)) SWIG_fail;
6765 {
6766 arg2 = (int)(SWIG_As_int(obj1));
6767 if (SWIG_arg_fail(2)) SWIG_fail;
6768 }
6769 {
6770 arg3 = (int)(SWIG_As_int(obj2));
6771 if (SWIG_arg_fail(3)) SWIG_fail;
6772 }
6773 {
6774 PyThreadState* __tstate = wxPyBeginAllowThreads();
6775 (arg1)->Move(arg2,arg3);
6776
6777 wxPyEndAllowThreads(__tstate);
6778 if (PyErr_Occurred()) SWIG_fail;
6779 }
6780 Py_INCREF(Py_None); resultobj = Py_None;
6781 return resultobj;
6782 fail:
6783 return NULL;
6784 }
6785
6786
6787 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6788 PyObject *resultobj;
6789 wxCaret *arg1 = (wxCaret *) 0 ;
6790 wxPoint *arg2 = 0 ;
6791 wxPoint temp2 ;
6792 PyObject * obj0 = 0 ;
6793 PyObject * obj1 = 0 ;
6794 char *kwnames[] = {
6795 (char *) "self",(char *) "pt", NULL
6796 };
6797
6798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6800 if (SWIG_arg_fail(1)) SWIG_fail;
6801 {
6802 arg2 = &temp2;
6803 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6804 }
6805 {
6806 PyThreadState* __tstate = wxPyBeginAllowThreads();
6807 (arg1)->Move((wxPoint const &)*arg2);
6808
6809 wxPyEndAllowThreads(__tstate);
6810 if (PyErr_Occurred()) SWIG_fail;
6811 }
6812 Py_INCREF(Py_None); resultobj = Py_None;
6813 return resultobj;
6814 fail:
6815 return NULL;
6816 }
6817
6818
6819 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6820 PyObject *resultobj;
6821 wxCaret *arg1 = (wxCaret *) 0 ;
6822 int arg2 ;
6823 int arg3 ;
6824 PyObject * obj0 = 0 ;
6825 PyObject * obj1 = 0 ;
6826 PyObject * obj2 = 0 ;
6827 char *kwnames[] = {
6828 (char *) "self",(char *) "width",(char *) "height", NULL
6829 };
6830
6831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6833 if (SWIG_arg_fail(1)) SWIG_fail;
6834 {
6835 arg2 = (int)(SWIG_As_int(obj1));
6836 if (SWIG_arg_fail(2)) SWIG_fail;
6837 }
6838 {
6839 arg3 = (int)(SWIG_As_int(obj2));
6840 if (SWIG_arg_fail(3)) SWIG_fail;
6841 }
6842 {
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 (arg1)->SetSize(arg2,arg3);
6845
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 Py_INCREF(Py_None); resultobj = Py_None;
6850 return resultobj;
6851 fail:
6852 return NULL;
6853 }
6854
6855
6856 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6857 PyObject *resultobj;
6858 wxCaret *arg1 = (wxCaret *) 0 ;
6859 wxSize *arg2 = 0 ;
6860 wxSize temp2 ;
6861 PyObject * obj0 = 0 ;
6862 PyObject * obj1 = 0 ;
6863 char *kwnames[] = {
6864 (char *) "self",(char *) "size", NULL
6865 };
6866
6867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6869 if (SWIG_arg_fail(1)) SWIG_fail;
6870 {
6871 arg2 = &temp2;
6872 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6873 }
6874 {
6875 PyThreadState* __tstate = wxPyBeginAllowThreads();
6876 (arg1)->SetSize((wxSize const &)*arg2);
6877
6878 wxPyEndAllowThreads(__tstate);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 Py_INCREF(Py_None); resultobj = Py_None;
6882 return resultobj;
6883 fail:
6884 return NULL;
6885 }
6886
6887
6888 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6889 PyObject *resultobj;
6890 wxCaret *arg1 = (wxCaret *) 0 ;
6891 int arg2 = (int) true ;
6892 PyObject * obj0 = 0 ;
6893 PyObject * obj1 = 0 ;
6894 char *kwnames[] = {
6895 (char *) "self",(char *) "show", NULL
6896 };
6897
6898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6900 if (SWIG_arg_fail(1)) SWIG_fail;
6901 if (obj1) {
6902 {
6903 arg2 = (int)(SWIG_As_int(obj1));
6904 if (SWIG_arg_fail(2)) SWIG_fail;
6905 }
6906 }
6907 {
6908 PyThreadState* __tstate = wxPyBeginAllowThreads();
6909 (arg1)->Show(arg2);
6910
6911 wxPyEndAllowThreads(__tstate);
6912 if (PyErr_Occurred()) SWIG_fail;
6913 }
6914 Py_INCREF(Py_None); resultobj = Py_None;
6915 return resultobj;
6916 fail:
6917 return NULL;
6918 }
6919
6920
6921 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6922 PyObject *resultobj;
6923 wxCaret *arg1 = (wxCaret *) 0 ;
6924 PyObject * obj0 = 0 ;
6925 char *kwnames[] = {
6926 (char *) "self", NULL
6927 };
6928
6929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6931 if (SWIG_arg_fail(1)) SWIG_fail;
6932 {
6933 PyThreadState* __tstate = wxPyBeginAllowThreads();
6934 (arg1)->Hide();
6935
6936 wxPyEndAllowThreads(__tstate);
6937 if (PyErr_Occurred()) SWIG_fail;
6938 }
6939 Py_INCREF(Py_None); resultobj = Py_None;
6940 return resultobj;
6941 fail:
6942 return NULL;
6943 }
6944
6945
6946 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6947 PyObject *resultobj;
6948 int result;
6949 char *kwnames[] = {
6950 NULL
6951 };
6952
6953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6954 {
6955 PyThreadState* __tstate = wxPyBeginAllowThreads();
6956 result = (int)wxCaret::GetBlinkTime();
6957
6958 wxPyEndAllowThreads(__tstate);
6959 if (PyErr_Occurred()) SWIG_fail;
6960 }
6961 {
6962 resultobj = SWIG_From_int((int)(result));
6963 }
6964 return resultobj;
6965 fail:
6966 return NULL;
6967 }
6968
6969
6970 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6971 PyObject *resultobj;
6972 int arg1 ;
6973 PyObject * obj0 = 0 ;
6974 char *kwnames[] = {
6975 (char *) "milliseconds", NULL
6976 };
6977
6978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6979 {
6980 arg1 = (int)(SWIG_As_int(obj0));
6981 if (SWIG_arg_fail(1)) SWIG_fail;
6982 }
6983 {
6984 PyThreadState* __tstate = wxPyBeginAllowThreads();
6985 wxCaret::SetBlinkTime(arg1);
6986
6987 wxPyEndAllowThreads(__tstate);
6988 if (PyErr_Occurred()) SWIG_fail;
6989 }
6990 Py_INCREF(Py_None); resultobj = Py_None;
6991 return resultobj;
6992 fail:
6993 return NULL;
6994 }
6995
6996
6997 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6998 PyObject *obj;
6999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7000 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
7001 Py_INCREF(obj);
7002 return Py_BuildValue((char *)"");
7003 }
7004 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7005 PyObject *resultobj;
7006 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7007 wxBusyCursor *result;
7008 PyObject * obj0 = 0 ;
7009 char *kwnames[] = {
7010 (char *) "cursor", NULL
7011 };
7012
7013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
7014 if (obj0) {
7015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
7016 if (SWIG_arg_fail(1)) SWIG_fail;
7017 }
7018 {
7019 if (!wxPyCheckForApp()) SWIG_fail;
7020 PyThreadState* __tstate = wxPyBeginAllowThreads();
7021 result = (wxBusyCursor *)new wxBusyCursor(arg1);
7022
7023 wxPyEndAllowThreads(__tstate);
7024 if (PyErr_Occurred()) SWIG_fail;
7025 }
7026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
7027 return resultobj;
7028 fail:
7029 return NULL;
7030 }
7031
7032
7033 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7034 PyObject *resultobj;
7035 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
7036 PyObject * obj0 = 0 ;
7037 char *kwnames[] = {
7038 (char *) "self", NULL
7039 };
7040
7041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
7042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7043 if (SWIG_arg_fail(1)) SWIG_fail;
7044 {
7045 PyThreadState* __tstate = wxPyBeginAllowThreads();
7046 delete arg1;
7047
7048 wxPyEndAllowThreads(__tstate);
7049 if (PyErr_Occurred()) SWIG_fail;
7050 }
7051 Py_INCREF(Py_None); resultobj = Py_None;
7052 return resultobj;
7053 fail:
7054 return NULL;
7055 }
7056
7057
7058 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7059 PyObject *obj;
7060 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7061 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7062 Py_INCREF(obj);
7063 return Py_BuildValue((char *)"");
7064 }
7065 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7066 PyObject *resultobj;
7067 wxWindow *arg1 = (wxWindow *) NULL ;
7068 wxWindowDisabler *result;
7069 PyObject * obj0 = 0 ;
7070 char *kwnames[] = {
7071 (char *) "winToSkip", NULL
7072 };
7073
7074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7075 if (obj0) {
7076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7077 if (SWIG_arg_fail(1)) SWIG_fail;
7078 }
7079 {
7080 if (!wxPyCheckForApp()) SWIG_fail;
7081 PyThreadState* __tstate = wxPyBeginAllowThreads();
7082 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7083
7084 wxPyEndAllowThreads(__tstate);
7085 if (PyErr_Occurred()) SWIG_fail;
7086 }
7087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7088 return resultobj;
7089 fail:
7090 return NULL;
7091 }
7092
7093
7094 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7095 PyObject *resultobj;
7096 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7097 PyObject * obj0 = 0 ;
7098 char *kwnames[] = {
7099 (char *) "self", NULL
7100 };
7101
7102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7104 if (SWIG_arg_fail(1)) SWIG_fail;
7105 {
7106 PyThreadState* __tstate = wxPyBeginAllowThreads();
7107 delete arg1;
7108
7109 wxPyEndAllowThreads(__tstate);
7110 if (PyErr_Occurred()) SWIG_fail;
7111 }
7112 Py_INCREF(Py_None); resultobj = Py_None;
7113 return resultobj;
7114 fail:
7115 return NULL;
7116 }
7117
7118
7119 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7120 PyObject *obj;
7121 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7122 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7123 Py_INCREF(obj);
7124 return Py_BuildValue((char *)"");
7125 }
7126 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7127 PyObject *resultobj;
7128 wxString *arg1 = 0 ;
7129 wxBusyInfo *result;
7130 bool temp1 = false ;
7131 PyObject * obj0 = 0 ;
7132 char *kwnames[] = {
7133 (char *) "message", NULL
7134 };
7135
7136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7137 {
7138 arg1 = wxString_in_helper(obj0);
7139 if (arg1 == NULL) SWIG_fail;
7140 temp1 = true;
7141 }
7142 {
7143 if (!wxPyCheckForApp()) SWIG_fail;
7144 PyThreadState* __tstate = wxPyBeginAllowThreads();
7145 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7146
7147 wxPyEndAllowThreads(__tstate);
7148 if (PyErr_Occurred()) SWIG_fail;
7149 }
7150 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7151 {
7152 if (temp1)
7153 delete arg1;
7154 }
7155 return resultobj;
7156 fail:
7157 {
7158 if (temp1)
7159 delete arg1;
7160 }
7161 return NULL;
7162 }
7163
7164
7165 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7166 PyObject *resultobj;
7167 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7168 PyObject * obj0 = 0 ;
7169 char *kwnames[] = {
7170 (char *) "self", NULL
7171 };
7172
7173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7175 if (SWIG_arg_fail(1)) SWIG_fail;
7176 {
7177 PyThreadState* __tstate = wxPyBeginAllowThreads();
7178 delete arg1;
7179
7180 wxPyEndAllowThreads(__tstate);
7181 if (PyErr_Occurred()) SWIG_fail;
7182 }
7183 Py_INCREF(Py_None); resultobj = Py_None;
7184 return resultobj;
7185 fail:
7186 return NULL;
7187 }
7188
7189
7190 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7191 PyObject *obj;
7192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7193 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7194 Py_INCREF(obj);
7195 return Py_BuildValue((char *)"");
7196 }
7197 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7198 PyObject *resultobj;
7199 wxStopWatch *result;
7200 char *kwnames[] = {
7201 NULL
7202 };
7203
7204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7205 {
7206 PyThreadState* __tstate = wxPyBeginAllowThreads();
7207 result = (wxStopWatch *)new wxStopWatch();
7208
7209 wxPyEndAllowThreads(__tstate);
7210 if (PyErr_Occurred()) SWIG_fail;
7211 }
7212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj;
7221 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7222 long arg2 = (long) 0 ;
7223 PyObject * obj0 = 0 ;
7224 PyObject * obj1 = 0 ;
7225 char *kwnames[] = {
7226 (char *) "self",(char *) "t0", NULL
7227 };
7228
7229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7231 if (SWIG_arg_fail(1)) SWIG_fail;
7232 if (obj1) {
7233 {
7234 arg2 = (long)(SWIG_As_long(obj1));
7235 if (SWIG_arg_fail(2)) SWIG_fail;
7236 }
7237 }
7238 {
7239 PyThreadState* __tstate = wxPyBeginAllowThreads();
7240 (arg1)->Start(arg2);
7241
7242 wxPyEndAllowThreads(__tstate);
7243 if (PyErr_Occurred()) SWIG_fail;
7244 }
7245 Py_INCREF(Py_None); resultobj = Py_None;
7246 return resultobj;
7247 fail:
7248 return NULL;
7249 }
7250
7251
7252 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7253 PyObject *resultobj;
7254 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7255 PyObject * obj0 = 0 ;
7256 char *kwnames[] = {
7257 (char *) "self", NULL
7258 };
7259
7260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7262 if (SWIG_arg_fail(1)) SWIG_fail;
7263 {
7264 PyThreadState* __tstate = wxPyBeginAllowThreads();
7265 (arg1)->Pause();
7266
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 Py_INCREF(Py_None); resultobj = Py_None;
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj;
7279 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7280 PyObject * obj0 = 0 ;
7281 char *kwnames[] = {
7282 (char *) "self", NULL
7283 };
7284
7285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7287 if (SWIG_arg_fail(1)) SWIG_fail;
7288 {
7289 PyThreadState* __tstate = wxPyBeginAllowThreads();
7290 (arg1)->Resume();
7291
7292 wxPyEndAllowThreads(__tstate);
7293 if (PyErr_Occurred()) SWIG_fail;
7294 }
7295 Py_INCREF(Py_None); resultobj = Py_None;
7296 return resultobj;
7297 fail:
7298 return NULL;
7299 }
7300
7301
7302 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7303 PyObject *resultobj;
7304 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7305 long result;
7306 PyObject * obj0 = 0 ;
7307 char *kwnames[] = {
7308 (char *) "self", NULL
7309 };
7310
7311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7313 if (SWIG_arg_fail(1)) SWIG_fail;
7314 {
7315 PyThreadState* __tstate = wxPyBeginAllowThreads();
7316 result = (long)((wxStopWatch const *)arg1)->Time();
7317
7318 wxPyEndAllowThreads(__tstate);
7319 if (PyErr_Occurred()) SWIG_fail;
7320 }
7321 {
7322 resultobj = SWIG_From_long((long)(result));
7323 }
7324 return resultobj;
7325 fail:
7326 return NULL;
7327 }
7328
7329
7330 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7331 PyObject *obj;
7332 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7333 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7334 Py_INCREF(obj);
7335 return Py_BuildValue((char *)"");
7336 }
7337 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7338 PyObject *resultobj;
7339 int arg1 = (int) 9 ;
7340 int arg2 = (int) wxID_FILE1 ;
7341 wxFileHistory *result;
7342 PyObject * obj0 = 0 ;
7343 PyObject * obj1 = 0 ;
7344 char *kwnames[] = {
7345 (char *) "maxFiles",(char *) "idBase", NULL
7346 };
7347
7348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7349 if (obj0) {
7350 {
7351 arg1 = (int)(SWIG_As_int(obj0));
7352 if (SWIG_arg_fail(1)) SWIG_fail;
7353 }
7354 }
7355 if (obj1) {
7356 {
7357 arg2 = (int)(SWIG_As_int(obj1));
7358 if (SWIG_arg_fail(2)) SWIG_fail;
7359 }
7360 }
7361 {
7362 PyThreadState* __tstate = wxPyBeginAllowThreads();
7363 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7364
7365 wxPyEndAllowThreads(__tstate);
7366 if (PyErr_Occurred()) SWIG_fail;
7367 }
7368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7369 return resultobj;
7370 fail:
7371 return NULL;
7372 }
7373
7374
7375 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7376 PyObject *resultobj;
7377 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7378 PyObject * obj0 = 0 ;
7379 char *kwnames[] = {
7380 (char *) "self", NULL
7381 };
7382
7383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7385 if (SWIG_arg_fail(1)) SWIG_fail;
7386 {
7387 PyThreadState* __tstate = wxPyBeginAllowThreads();
7388 delete arg1;
7389
7390 wxPyEndAllowThreads(__tstate);
7391 if (PyErr_Occurred()) SWIG_fail;
7392 }
7393 Py_INCREF(Py_None); resultobj = Py_None;
7394 return resultobj;
7395 fail:
7396 return NULL;
7397 }
7398
7399
7400 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7401 PyObject *resultobj;
7402 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7403 wxString *arg2 = 0 ;
7404 bool temp2 = false ;
7405 PyObject * obj0 = 0 ;
7406 PyObject * obj1 = 0 ;
7407 char *kwnames[] = {
7408 (char *) "self",(char *) "file", NULL
7409 };
7410
7411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7413 if (SWIG_arg_fail(1)) SWIG_fail;
7414 {
7415 arg2 = wxString_in_helper(obj1);
7416 if (arg2 == NULL) SWIG_fail;
7417 temp2 = true;
7418 }
7419 {
7420 PyThreadState* __tstate = wxPyBeginAllowThreads();
7421 (arg1)->AddFileToHistory((wxString const &)*arg2);
7422
7423 wxPyEndAllowThreads(__tstate);
7424 if (PyErr_Occurred()) SWIG_fail;
7425 }
7426 Py_INCREF(Py_None); resultobj = Py_None;
7427 {
7428 if (temp2)
7429 delete arg2;
7430 }
7431 return resultobj;
7432 fail:
7433 {
7434 if (temp2)
7435 delete arg2;
7436 }
7437 return NULL;
7438 }
7439
7440
7441 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7442 PyObject *resultobj;
7443 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7444 int arg2 ;
7445 PyObject * obj0 = 0 ;
7446 PyObject * obj1 = 0 ;
7447 char *kwnames[] = {
7448 (char *) "self",(char *) "i", NULL
7449 };
7450
7451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7453 if (SWIG_arg_fail(1)) SWIG_fail;
7454 {
7455 arg2 = (int)(SWIG_As_int(obj1));
7456 if (SWIG_arg_fail(2)) SWIG_fail;
7457 }
7458 {
7459 PyThreadState* __tstate = wxPyBeginAllowThreads();
7460 (arg1)->RemoveFileFromHistory(arg2);
7461
7462 wxPyEndAllowThreads(__tstate);
7463 if (PyErr_Occurred()) SWIG_fail;
7464 }
7465 Py_INCREF(Py_None); resultobj = Py_None;
7466 return resultobj;
7467 fail:
7468 return NULL;
7469 }
7470
7471
7472 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7473 PyObject *resultobj;
7474 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7475 int result;
7476 PyObject * obj0 = 0 ;
7477 char *kwnames[] = {
7478 (char *) "self", NULL
7479 };
7480
7481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7483 if (SWIG_arg_fail(1)) SWIG_fail;
7484 {
7485 PyThreadState* __tstate = wxPyBeginAllowThreads();
7486 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7487
7488 wxPyEndAllowThreads(__tstate);
7489 if (PyErr_Occurred()) SWIG_fail;
7490 }
7491 {
7492 resultobj = SWIG_From_int((int)(result));
7493 }
7494 return resultobj;
7495 fail:
7496 return NULL;
7497 }
7498
7499
7500 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7501 PyObject *resultobj;
7502 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7503 wxMenu *arg2 = (wxMenu *) 0 ;
7504 PyObject * obj0 = 0 ;
7505 PyObject * obj1 = 0 ;
7506 char *kwnames[] = {
7507 (char *) "self",(char *) "menu", NULL
7508 };
7509
7510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7512 if (SWIG_arg_fail(1)) SWIG_fail;
7513 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7514 if (SWIG_arg_fail(2)) SWIG_fail;
7515 {
7516 PyThreadState* __tstate = wxPyBeginAllowThreads();
7517 (arg1)->UseMenu(arg2);
7518
7519 wxPyEndAllowThreads(__tstate);
7520 if (PyErr_Occurred()) SWIG_fail;
7521 }
7522 Py_INCREF(Py_None); resultobj = Py_None;
7523 return resultobj;
7524 fail:
7525 return NULL;
7526 }
7527
7528
7529 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7530 PyObject *resultobj;
7531 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7532 wxMenu *arg2 = (wxMenu *) 0 ;
7533 PyObject * obj0 = 0 ;
7534 PyObject * obj1 = 0 ;
7535 char *kwnames[] = {
7536 (char *) "self",(char *) "menu", NULL
7537 };
7538
7539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7541 if (SWIG_arg_fail(1)) SWIG_fail;
7542 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7543 if (SWIG_arg_fail(2)) SWIG_fail;
7544 {
7545 PyThreadState* __tstate = wxPyBeginAllowThreads();
7546 (arg1)->RemoveMenu(arg2);
7547
7548 wxPyEndAllowThreads(__tstate);
7549 if (PyErr_Occurred()) SWIG_fail;
7550 }
7551 Py_INCREF(Py_None); resultobj = Py_None;
7552 return resultobj;
7553 fail:
7554 return NULL;
7555 }
7556
7557
7558 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7559 PyObject *resultobj;
7560 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7561 wxConfigBase *arg2 = 0 ;
7562 PyObject * obj0 = 0 ;
7563 PyObject * obj1 = 0 ;
7564 char *kwnames[] = {
7565 (char *) "self",(char *) "config", NULL
7566 };
7567
7568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7570 if (SWIG_arg_fail(1)) SWIG_fail;
7571 {
7572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7573 if (SWIG_arg_fail(2)) SWIG_fail;
7574 if (arg2 == NULL) {
7575 SWIG_null_ref("wxConfigBase");
7576 }
7577 if (SWIG_arg_fail(2)) SWIG_fail;
7578 }
7579 {
7580 PyThreadState* __tstate = wxPyBeginAllowThreads();
7581 (arg1)->Load(*arg2);
7582
7583 wxPyEndAllowThreads(__tstate);
7584 if (PyErr_Occurred()) SWIG_fail;
7585 }
7586 Py_INCREF(Py_None); resultobj = Py_None;
7587 return resultobj;
7588 fail:
7589 return NULL;
7590 }
7591
7592
7593 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7594 PyObject *resultobj;
7595 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7596 wxConfigBase *arg2 = 0 ;
7597 PyObject * obj0 = 0 ;
7598 PyObject * obj1 = 0 ;
7599 char *kwnames[] = {
7600 (char *) "self",(char *) "config", NULL
7601 };
7602
7603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7605 if (SWIG_arg_fail(1)) SWIG_fail;
7606 {
7607 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7608 if (SWIG_arg_fail(2)) SWIG_fail;
7609 if (arg2 == NULL) {
7610 SWIG_null_ref("wxConfigBase");
7611 }
7612 if (SWIG_arg_fail(2)) SWIG_fail;
7613 }
7614 {
7615 PyThreadState* __tstate = wxPyBeginAllowThreads();
7616 (arg1)->Save(*arg2);
7617
7618 wxPyEndAllowThreads(__tstate);
7619 if (PyErr_Occurred()) SWIG_fail;
7620 }
7621 Py_INCREF(Py_None); resultobj = Py_None;
7622 return resultobj;
7623 fail:
7624 return NULL;
7625 }
7626
7627
7628 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7629 PyObject *resultobj;
7630 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7631 PyObject * obj0 = 0 ;
7632 char *kwnames[] = {
7633 (char *) "self", NULL
7634 };
7635
7636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7638 if (SWIG_arg_fail(1)) SWIG_fail;
7639 {
7640 PyThreadState* __tstate = wxPyBeginAllowThreads();
7641 (arg1)->AddFilesToMenu();
7642
7643 wxPyEndAllowThreads(__tstate);
7644 if (PyErr_Occurred()) SWIG_fail;
7645 }
7646 Py_INCREF(Py_None); resultobj = Py_None;
7647 return resultobj;
7648 fail:
7649 return NULL;
7650 }
7651
7652
7653 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7654 PyObject *resultobj;
7655 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7656 wxMenu *arg2 = (wxMenu *) 0 ;
7657 PyObject * obj0 = 0 ;
7658 PyObject * obj1 = 0 ;
7659 char *kwnames[] = {
7660 (char *) "self",(char *) "menu", NULL
7661 };
7662
7663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7665 if (SWIG_arg_fail(1)) SWIG_fail;
7666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7667 if (SWIG_arg_fail(2)) SWIG_fail;
7668 {
7669 PyThreadState* __tstate = wxPyBeginAllowThreads();
7670 (arg1)->AddFilesToMenu(arg2);
7671
7672 wxPyEndAllowThreads(__tstate);
7673 if (PyErr_Occurred()) SWIG_fail;
7674 }
7675 Py_INCREF(Py_None); resultobj = Py_None;
7676 return resultobj;
7677 fail:
7678 return NULL;
7679 }
7680
7681
7682 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7683 PyObject *resultobj;
7684 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7685 int arg2 ;
7686 wxString result;
7687 PyObject * obj0 = 0 ;
7688 PyObject * obj1 = 0 ;
7689 char *kwnames[] = {
7690 (char *) "self",(char *) "i", NULL
7691 };
7692
7693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7695 if (SWIG_arg_fail(1)) SWIG_fail;
7696 {
7697 arg2 = (int)(SWIG_As_int(obj1));
7698 if (SWIG_arg_fail(2)) SWIG_fail;
7699 }
7700 {
7701 PyThreadState* __tstate = wxPyBeginAllowThreads();
7702 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7703
7704 wxPyEndAllowThreads(__tstate);
7705 if (PyErr_Occurred()) SWIG_fail;
7706 }
7707 {
7708 #if wxUSE_UNICODE
7709 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7710 #else
7711 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7712 #endif
7713 }
7714 return resultobj;
7715 fail:
7716 return NULL;
7717 }
7718
7719
7720 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7721 PyObject *resultobj;
7722 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7723 int result;
7724 PyObject * obj0 = 0 ;
7725 char *kwnames[] = {
7726 (char *) "self", NULL
7727 };
7728
7729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7731 if (SWIG_arg_fail(1)) SWIG_fail;
7732 {
7733 PyThreadState* __tstate = wxPyBeginAllowThreads();
7734 result = (int)((wxFileHistory const *)arg1)->GetCount();
7735
7736 wxPyEndAllowThreads(__tstate);
7737 if (PyErr_Occurred()) SWIG_fail;
7738 }
7739 {
7740 resultobj = SWIG_From_int((int)(result));
7741 }
7742 return resultobj;
7743 fail:
7744 return NULL;
7745 }
7746
7747
7748 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7749 PyObject *obj;
7750 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7751 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7752 Py_INCREF(obj);
7753 return Py_BuildValue((char *)"");
7754 }
7755 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7756 PyObject *resultobj;
7757 wxString *arg1 = 0 ;
7758 wxString const &arg2_defvalue = wxPyEmptyString ;
7759 wxString *arg2 = (wxString *) &arg2_defvalue ;
7760 wxSingleInstanceChecker *result;
7761 bool temp1 = false ;
7762 bool temp2 = false ;
7763 PyObject * obj0 = 0 ;
7764 PyObject * obj1 = 0 ;
7765 char *kwnames[] = {
7766 (char *) "name",(char *) "path", NULL
7767 };
7768
7769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7770 {
7771 arg1 = wxString_in_helper(obj0);
7772 if (arg1 == NULL) SWIG_fail;
7773 temp1 = true;
7774 }
7775 if (obj1) {
7776 {
7777 arg2 = wxString_in_helper(obj1);
7778 if (arg2 == NULL) SWIG_fail;
7779 temp2 = true;
7780 }
7781 }
7782 {
7783 PyThreadState* __tstate = wxPyBeginAllowThreads();
7784 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7785
7786 wxPyEndAllowThreads(__tstate);
7787 if (PyErr_Occurred()) SWIG_fail;
7788 }
7789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7790 {
7791 if (temp1)
7792 delete arg1;
7793 }
7794 {
7795 if (temp2)
7796 delete arg2;
7797 }
7798 return resultobj;
7799 fail:
7800 {
7801 if (temp1)
7802 delete arg1;
7803 }
7804 {
7805 if (temp2)
7806 delete arg2;
7807 }
7808 return NULL;
7809 }
7810
7811
7812 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7813 PyObject *resultobj;
7814 wxSingleInstanceChecker *result;
7815 char *kwnames[] = {
7816 NULL
7817 };
7818
7819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7820 {
7821 PyThreadState* __tstate = wxPyBeginAllowThreads();
7822 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7823
7824 wxPyEndAllowThreads(__tstate);
7825 if (PyErr_Occurred()) SWIG_fail;
7826 }
7827 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7828 return resultobj;
7829 fail:
7830 return NULL;
7831 }
7832
7833
7834 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7835 PyObject *resultobj;
7836 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7837 PyObject * obj0 = 0 ;
7838 char *kwnames[] = {
7839 (char *) "self", NULL
7840 };
7841
7842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7844 if (SWIG_arg_fail(1)) SWIG_fail;
7845 {
7846 PyThreadState* __tstate = wxPyBeginAllowThreads();
7847 delete arg1;
7848
7849 wxPyEndAllowThreads(__tstate);
7850 if (PyErr_Occurred()) SWIG_fail;
7851 }
7852 Py_INCREF(Py_None); resultobj = Py_None;
7853 return resultobj;
7854 fail:
7855 return NULL;
7856 }
7857
7858
7859 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7860 PyObject *resultobj;
7861 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7862 wxString *arg2 = 0 ;
7863 wxString const &arg3_defvalue = wxPyEmptyString ;
7864 wxString *arg3 = (wxString *) &arg3_defvalue ;
7865 bool result;
7866 bool temp2 = false ;
7867 bool temp3 = false ;
7868 PyObject * obj0 = 0 ;
7869 PyObject * obj1 = 0 ;
7870 PyObject * obj2 = 0 ;
7871 char *kwnames[] = {
7872 (char *) "self",(char *) "name",(char *) "path", NULL
7873 };
7874
7875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7877 if (SWIG_arg_fail(1)) SWIG_fail;
7878 {
7879 arg2 = wxString_in_helper(obj1);
7880 if (arg2 == NULL) SWIG_fail;
7881 temp2 = true;
7882 }
7883 if (obj2) {
7884 {
7885 arg3 = wxString_in_helper(obj2);
7886 if (arg3 == NULL) SWIG_fail;
7887 temp3 = true;
7888 }
7889 }
7890 {
7891 PyThreadState* __tstate = wxPyBeginAllowThreads();
7892 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7893
7894 wxPyEndAllowThreads(__tstate);
7895 if (PyErr_Occurred()) SWIG_fail;
7896 }
7897 {
7898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7899 }
7900 {
7901 if (temp2)
7902 delete arg2;
7903 }
7904 {
7905 if (temp3)
7906 delete arg3;
7907 }
7908 return resultobj;
7909 fail:
7910 {
7911 if (temp2)
7912 delete arg2;
7913 }
7914 {
7915 if (temp3)
7916 delete arg3;
7917 }
7918 return NULL;
7919 }
7920
7921
7922 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7923 PyObject *resultobj;
7924 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7925 bool result;
7926 PyObject * obj0 = 0 ;
7927 char *kwnames[] = {
7928 (char *) "self", NULL
7929 };
7930
7931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7933 if (SWIG_arg_fail(1)) SWIG_fail;
7934 {
7935 PyThreadState* __tstate = wxPyBeginAllowThreads();
7936 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7937
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 {
7942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7943 }
7944 return resultobj;
7945 fail:
7946 return NULL;
7947 }
7948
7949
7950 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7951 PyObject *obj;
7952 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7953 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7954 Py_INCREF(obj);
7955 return Py_BuildValue((char *)"");
7956 }
7957 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7958 PyObject *resultobj;
7959 wxWindow *arg1 = (wxWindow *) 0 ;
7960 wxDC *arg2 = 0 ;
7961 bool result;
7962 PyObject * obj0 = 0 ;
7963 PyObject * obj1 = 0 ;
7964 char *kwnames[] = {
7965 (char *) "window",(char *) "dc", NULL
7966 };
7967
7968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7970 if (SWIG_arg_fail(1)) SWIG_fail;
7971 {
7972 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7973 if (SWIG_arg_fail(2)) SWIG_fail;
7974 if (arg2 == NULL) {
7975 SWIG_null_ref("wxDC");
7976 }
7977 if (SWIG_arg_fail(2)) SWIG_fail;
7978 }
7979 {
7980 PyThreadState* __tstate = wxPyBeginAllowThreads();
7981 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7982
7983 wxPyEndAllowThreads(__tstate);
7984 if (PyErr_Occurred()) SWIG_fail;
7985 }
7986 {
7987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7988 }
7989 return resultobj;
7990 fail:
7991 return NULL;
7992 }
7993
7994
7995 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7996 PyObject *resultobj;
7997 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7998 PyObject * obj0 = 0 ;
7999 char *kwnames[] = {
8000 (char *) "self", NULL
8001 };
8002
8003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
8004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8005 if (SWIG_arg_fail(1)) SWIG_fail;
8006 {
8007 PyThreadState* __tstate = wxPyBeginAllowThreads();
8008 delete arg1;
8009
8010 wxPyEndAllowThreads(__tstate);
8011 if (PyErr_Occurred()) SWIG_fail;
8012 }
8013 Py_INCREF(Py_None); resultobj = Py_None;
8014 return resultobj;
8015 fail:
8016 return NULL;
8017 }
8018
8019
8020 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
8021 PyObject *resultobj;
8022 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8023 wxString result;
8024 PyObject * obj0 = 0 ;
8025 char *kwnames[] = {
8026 (char *) "self", NULL
8027 };
8028
8029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
8030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8031 if (SWIG_arg_fail(1)) SWIG_fail;
8032 {
8033 PyThreadState* __tstate = wxPyBeginAllowThreads();
8034 result = (arg1)->GetTip();
8035
8036 wxPyEndAllowThreads(__tstate);
8037 if (PyErr_Occurred()) SWIG_fail;
8038 }
8039 {
8040 #if wxUSE_UNICODE
8041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8042 #else
8043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8044 #endif
8045 }
8046 return resultobj;
8047 fail:
8048 return NULL;
8049 }
8050
8051
8052 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8053 PyObject *resultobj;
8054 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8055 size_t result;
8056 PyObject * obj0 = 0 ;
8057 char *kwnames[] = {
8058 (char *) "self", NULL
8059 };
8060
8061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8063 if (SWIG_arg_fail(1)) SWIG_fail;
8064 {
8065 PyThreadState* __tstate = wxPyBeginAllowThreads();
8066 result = (size_t)(arg1)->GetCurrentTip();
8067
8068 wxPyEndAllowThreads(__tstate);
8069 if (PyErr_Occurred()) SWIG_fail;
8070 }
8071 {
8072 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8073 }
8074 return resultobj;
8075 fail:
8076 return NULL;
8077 }
8078
8079
8080 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8081 PyObject *resultobj;
8082 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8083 wxString *arg2 = 0 ;
8084 wxString result;
8085 bool temp2 = false ;
8086 PyObject * obj0 = 0 ;
8087 PyObject * obj1 = 0 ;
8088 char *kwnames[] = {
8089 (char *) "self",(char *) "tip", NULL
8090 };
8091
8092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8094 if (SWIG_arg_fail(1)) SWIG_fail;
8095 {
8096 arg2 = wxString_in_helper(obj1);
8097 if (arg2 == NULL) SWIG_fail;
8098 temp2 = true;
8099 }
8100 {
8101 PyThreadState* __tstate = wxPyBeginAllowThreads();
8102 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8103
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 {
8108 #if wxUSE_UNICODE
8109 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8110 #else
8111 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8112 #endif
8113 }
8114 {
8115 if (temp2)
8116 delete arg2;
8117 }
8118 return resultobj;
8119 fail:
8120 {
8121 if (temp2)
8122 delete arg2;
8123 }
8124 return NULL;
8125 }
8126
8127
8128 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8129 PyObject *obj;
8130 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8131 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8132 Py_INCREF(obj);
8133 return Py_BuildValue((char *)"");
8134 }
8135 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8136 PyObject *resultobj;
8137 size_t arg1 ;
8138 wxPyTipProvider *result;
8139 PyObject * obj0 = 0 ;
8140 char *kwnames[] = {
8141 (char *) "currentTip", NULL
8142 };
8143
8144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8145 {
8146 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8147 if (SWIG_arg_fail(1)) SWIG_fail;
8148 }
8149 {
8150 PyThreadState* __tstate = wxPyBeginAllowThreads();
8151 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8152
8153 wxPyEndAllowThreads(__tstate);
8154 if (PyErr_Occurred()) SWIG_fail;
8155 }
8156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8157 return resultobj;
8158 fail:
8159 return NULL;
8160 }
8161
8162
8163 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8164 PyObject *resultobj;
8165 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8166 PyObject *arg2 = (PyObject *) 0 ;
8167 PyObject *arg3 = (PyObject *) 0 ;
8168 PyObject * obj0 = 0 ;
8169 PyObject * obj1 = 0 ;
8170 PyObject * obj2 = 0 ;
8171 char *kwnames[] = {
8172 (char *) "self",(char *) "self",(char *) "_class", NULL
8173 };
8174
8175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8177 if (SWIG_arg_fail(1)) SWIG_fail;
8178 arg2 = obj1;
8179 arg3 = obj2;
8180 {
8181 PyThreadState* __tstate = wxPyBeginAllowThreads();
8182 (arg1)->_setCallbackInfo(arg2,arg3);
8183
8184 wxPyEndAllowThreads(__tstate);
8185 if (PyErr_Occurred()) SWIG_fail;
8186 }
8187 Py_INCREF(Py_None); resultobj = Py_None;
8188 return resultobj;
8189 fail:
8190 return NULL;
8191 }
8192
8193
8194 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8195 PyObject *obj;
8196 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8197 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8198 Py_INCREF(obj);
8199 return Py_BuildValue((char *)"");
8200 }
8201 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8202 PyObject *resultobj;
8203 wxWindow *arg1 = (wxWindow *) 0 ;
8204 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8205 bool arg3 = (bool) true ;
8206 bool result;
8207 PyObject * obj0 = 0 ;
8208 PyObject * obj1 = 0 ;
8209 PyObject * obj2 = 0 ;
8210 char *kwnames[] = {
8211 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8212 };
8213
8214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8216 if (SWIG_arg_fail(1)) SWIG_fail;
8217 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8218 if (SWIG_arg_fail(2)) SWIG_fail;
8219 if (obj2) {
8220 {
8221 arg3 = (bool)(SWIG_As_bool(obj2));
8222 if (SWIG_arg_fail(3)) SWIG_fail;
8223 }
8224 }
8225 {
8226 if (!wxPyCheckForApp()) SWIG_fail;
8227 PyThreadState* __tstate = wxPyBeginAllowThreads();
8228 result = (bool)wxShowTip(arg1,arg2,arg3);
8229
8230 wxPyEndAllowThreads(__tstate);
8231 if (PyErr_Occurred()) SWIG_fail;
8232 }
8233 {
8234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8235 }
8236 return resultobj;
8237 fail:
8238 return NULL;
8239 }
8240
8241
8242 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8243 PyObject *resultobj;
8244 wxString *arg1 = 0 ;
8245 size_t arg2 ;
8246 wxTipProvider *result;
8247 bool temp1 = false ;
8248 PyObject * obj0 = 0 ;
8249 PyObject * obj1 = 0 ;
8250 char *kwnames[] = {
8251 (char *) "filename",(char *) "currentTip", NULL
8252 };
8253
8254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8255 {
8256 arg1 = wxString_in_helper(obj0);
8257 if (arg1 == NULL) SWIG_fail;
8258 temp1 = true;
8259 }
8260 {
8261 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8262 if (SWIG_arg_fail(2)) SWIG_fail;
8263 }
8264 {
8265 if (!wxPyCheckForApp()) SWIG_fail;
8266 PyThreadState* __tstate = wxPyBeginAllowThreads();
8267 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8268
8269 wxPyEndAllowThreads(__tstate);
8270 if (PyErr_Occurred()) SWIG_fail;
8271 }
8272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8273 {
8274 if (temp1)
8275 delete arg1;
8276 }
8277 return resultobj;
8278 fail:
8279 {
8280 if (temp1)
8281 delete arg1;
8282 }
8283 return NULL;
8284 }
8285
8286
8287 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8288 PyObject *resultobj;
8289 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8290 int arg2 = (int) -1 ;
8291 wxPyTimer *result;
8292 PyObject * obj0 = 0 ;
8293 PyObject * obj1 = 0 ;
8294 char *kwnames[] = {
8295 (char *) "owner",(char *) "id", NULL
8296 };
8297
8298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8299 if (obj0) {
8300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8301 if (SWIG_arg_fail(1)) SWIG_fail;
8302 }
8303 if (obj1) {
8304 {
8305 arg2 = (int)(SWIG_As_int(obj1));
8306 if (SWIG_arg_fail(2)) SWIG_fail;
8307 }
8308 }
8309 {
8310 if (!wxPyCheckForApp()) SWIG_fail;
8311 PyThreadState* __tstate = wxPyBeginAllowThreads();
8312 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8313
8314 wxPyEndAllowThreads(__tstate);
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8318 return resultobj;
8319 fail:
8320 return NULL;
8321 }
8322
8323
8324 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8325 PyObject *resultobj;
8326 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8327 PyObject * obj0 = 0 ;
8328 char *kwnames[] = {
8329 (char *) "self", NULL
8330 };
8331
8332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8334 if (SWIG_arg_fail(1)) SWIG_fail;
8335 {
8336 PyThreadState* __tstate = wxPyBeginAllowThreads();
8337 delete arg1;
8338
8339 wxPyEndAllowThreads(__tstate);
8340 if (PyErr_Occurred()) SWIG_fail;
8341 }
8342 Py_INCREF(Py_None); resultobj = Py_None;
8343 return resultobj;
8344 fail:
8345 return NULL;
8346 }
8347
8348
8349 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8350 PyObject *resultobj;
8351 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8352 PyObject *arg2 = (PyObject *) 0 ;
8353 PyObject *arg3 = (PyObject *) 0 ;
8354 int arg4 = (int) 1 ;
8355 PyObject * obj0 = 0 ;
8356 PyObject * obj1 = 0 ;
8357 PyObject * obj2 = 0 ;
8358 PyObject * obj3 = 0 ;
8359 char *kwnames[] = {
8360 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8361 };
8362
8363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8365 if (SWIG_arg_fail(1)) SWIG_fail;
8366 arg2 = obj1;
8367 arg3 = obj2;
8368 if (obj3) {
8369 {
8370 arg4 = (int)(SWIG_As_int(obj3));
8371 if (SWIG_arg_fail(4)) SWIG_fail;
8372 }
8373 }
8374 {
8375 PyThreadState* __tstate = wxPyBeginAllowThreads();
8376 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8377
8378 wxPyEndAllowThreads(__tstate);
8379 if (PyErr_Occurred()) SWIG_fail;
8380 }
8381 Py_INCREF(Py_None); resultobj = Py_None;
8382 return resultobj;
8383 fail:
8384 return NULL;
8385 }
8386
8387
8388 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8389 PyObject *resultobj;
8390 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8391 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8392 int arg3 = (int) -1 ;
8393 PyObject * obj0 = 0 ;
8394 PyObject * obj1 = 0 ;
8395 PyObject * obj2 = 0 ;
8396 char *kwnames[] = {
8397 (char *) "self",(char *) "owner",(char *) "id", NULL
8398 };
8399
8400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8402 if (SWIG_arg_fail(1)) SWIG_fail;
8403 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8404 if (SWIG_arg_fail(2)) SWIG_fail;
8405 if (obj2) {
8406 {
8407 arg3 = (int)(SWIG_As_int(obj2));
8408 if (SWIG_arg_fail(3)) SWIG_fail;
8409 }
8410 }
8411 {
8412 PyThreadState* __tstate = wxPyBeginAllowThreads();
8413 (arg1)->SetOwner(arg2,arg3);
8414
8415 wxPyEndAllowThreads(__tstate);
8416 if (PyErr_Occurred()) SWIG_fail;
8417 }
8418 Py_INCREF(Py_None); resultobj = Py_None;
8419 return resultobj;
8420 fail:
8421 return NULL;
8422 }
8423
8424
8425 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8426 PyObject *resultobj;
8427 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8428 wxEvtHandler *result;
8429 PyObject * obj0 = 0 ;
8430 char *kwnames[] = {
8431 (char *) "self", NULL
8432 };
8433
8434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8436 if (SWIG_arg_fail(1)) SWIG_fail;
8437 {
8438 PyThreadState* __tstate = wxPyBeginAllowThreads();
8439 result = (wxEvtHandler *)(arg1)->GetOwner();
8440
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 {
8445 resultobj = wxPyMake_wxObject(result, 0);
8446 }
8447 return resultobj;
8448 fail:
8449 return NULL;
8450 }
8451
8452
8453 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8454 PyObject *resultobj;
8455 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8456 int arg2 = (int) -1 ;
8457 bool arg3 = (bool) false ;
8458 bool result;
8459 PyObject * obj0 = 0 ;
8460 PyObject * obj1 = 0 ;
8461 PyObject * obj2 = 0 ;
8462 char *kwnames[] = {
8463 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8464 };
8465
8466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8468 if (SWIG_arg_fail(1)) SWIG_fail;
8469 if (obj1) {
8470 {
8471 arg2 = (int)(SWIG_As_int(obj1));
8472 if (SWIG_arg_fail(2)) SWIG_fail;
8473 }
8474 }
8475 if (obj2) {
8476 {
8477 arg3 = (bool)(SWIG_As_bool(obj2));
8478 if (SWIG_arg_fail(3)) SWIG_fail;
8479 }
8480 }
8481 {
8482 PyThreadState* __tstate = wxPyBeginAllowThreads();
8483 result = (bool)(arg1)->Start(arg2,arg3);
8484
8485 wxPyEndAllowThreads(__tstate);
8486 if (PyErr_Occurred()) SWIG_fail;
8487 }
8488 {
8489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8490 }
8491 return resultobj;
8492 fail:
8493 return NULL;
8494 }
8495
8496
8497 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8498 PyObject *resultobj;
8499 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8500 PyObject * obj0 = 0 ;
8501 char *kwnames[] = {
8502 (char *) "self", NULL
8503 };
8504
8505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8507 if (SWIG_arg_fail(1)) SWIG_fail;
8508 {
8509 PyThreadState* __tstate = wxPyBeginAllowThreads();
8510 (arg1)->Stop();
8511
8512 wxPyEndAllowThreads(__tstate);
8513 if (PyErr_Occurred()) SWIG_fail;
8514 }
8515 Py_INCREF(Py_None); resultobj = Py_None;
8516 return resultobj;
8517 fail:
8518 return NULL;
8519 }
8520
8521
8522 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8523 PyObject *resultobj;
8524 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8525 bool result;
8526 PyObject * obj0 = 0 ;
8527 char *kwnames[] = {
8528 (char *) "self", NULL
8529 };
8530
8531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8533 if (SWIG_arg_fail(1)) SWIG_fail;
8534 {
8535 PyThreadState* __tstate = wxPyBeginAllowThreads();
8536 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8537
8538 wxPyEndAllowThreads(__tstate);
8539 if (PyErr_Occurred()) SWIG_fail;
8540 }
8541 {
8542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8543 }
8544 return resultobj;
8545 fail:
8546 return NULL;
8547 }
8548
8549
8550 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8551 PyObject *resultobj;
8552 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8553 int result;
8554 PyObject * obj0 = 0 ;
8555 char *kwnames[] = {
8556 (char *) "self", NULL
8557 };
8558
8559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8561 if (SWIG_arg_fail(1)) SWIG_fail;
8562 {
8563 PyThreadState* __tstate = wxPyBeginAllowThreads();
8564 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8565
8566 wxPyEndAllowThreads(__tstate);
8567 if (PyErr_Occurred()) SWIG_fail;
8568 }
8569 {
8570 resultobj = SWIG_From_int((int)(result));
8571 }
8572 return resultobj;
8573 fail:
8574 return NULL;
8575 }
8576
8577
8578 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8579 PyObject *resultobj;
8580 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8581 bool result;
8582 PyObject * obj0 = 0 ;
8583 char *kwnames[] = {
8584 (char *) "self", NULL
8585 };
8586
8587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8589 if (SWIG_arg_fail(1)) SWIG_fail;
8590 {
8591 PyThreadState* __tstate = wxPyBeginAllowThreads();
8592 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8593
8594 wxPyEndAllowThreads(__tstate);
8595 if (PyErr_Occurred()) SWIG_fail;
8596 }
8597 {
8598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8599 }
8600 return resultobj;
8601 fail:
8602 return NULL;
8603 }
8604
8605
8606 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8607 PyObject *resultobj;
8608 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8609 int result;
8610 PyObject * obj0 = 0 ;
8611 char *kwnames[] = {
8612 (char *) "self", NULL
8613 };
8614
8615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8617 if (SWIG_arg_fail(1)) SWIG_fail;
8618 {
8619 PyThreadState* __tstate = wxPyBeginAllowThreads();
8620 result = (int)((wxPyTimer const *)arg1)->GetId();
8621
8622 wxPyEndAllowThreads(__tstate);
8623 if (PyErr_Occurred()) SWIG_fail;
8624 }
8625 {
8626 resultobj = SWIG_From_int((int)(result));
8627 }
8628 return resultobj;
8629 fail:
8630 return NULL;
8631 }
8632
8633
8634 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8635 PyObject *obj;
8636 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8637 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8638 Py_INCREF(obj);
8639 return Py_BuildValue((char *)"");
8640 }
8641 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8642 PyObject *resultobj;
8643 int arg1 = (int) 0 ;
8644 int arg2 = (int) 0 ;
8645 wxTimerEvent *result;
8646 PyObject * obj0 = 0 ;
8647 PyObject * obj1 = 0 ;
8648 char *kwnames[] = {
8649 (char *) "timerid",(char *) "interval", NULL
8650 };
8651
8652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8653 if (obj0) {
8654 {
8655 arg1 = (int)(SWIG_As_int(obj0));
8656 if (SWIG_arg_fail(1)) SWIG_fail;
8657 }
8658 }
8659 if (obj1) {
8660 {
8661 arg2 = (int)(SWIG_As_int(obj1));
8662 if (SWIG_arg_fail(2)) SWIG_fail;
8663 }
8664 }
8665 {
8666 PyThreadState* __tstate = wxPyBeginAllowThreads();
8667 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8668
8669 wxPyEndAllowThreads(__tstate);
8670 if (PyErr_Occurred()) SWIG_fail;
8671 }
8672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8673 return resultobj;
8674 fail:
8675 return NULL;
8676 }
8677
8678
8679 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8680 PyObject *resultobj;
8681 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8682 int result;
8683 PyObject * obj0 = 0 ;
8684 char *kwnames[] = {
8685 (char *) "self", NULL
8686 };
8687
8688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8690 if (SWIG_arg_fail(1)) SWIG_fail;
8691 {
8692 PyThreadState* __tstate = wxPyBeginAllowThreads();
8693 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8694
8695 wxPyEndAllowThreads(__tstate);
8696 if (PyErr_Occurred()) SWIG_fail;
8697 }
8698 {
8699 resultobj = SWIG_From_int((int)(result));
8700 }
8701 return resultobj;
8702 fail:
8703 return NULL;
8704 }
8705
8706
8707 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8708 PyObject *obj;
8709 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8710 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8711 Py_INCREF(obj);
8712 return Py_BuildValue((char *)"");
8713 }
8714 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8715 PyObject *resultobj;
8716 wxTimer *arg1 = 0 ;
8717 wxTimerRunner *result;
8718 PyObject * obj0 = 0 ;
8719
8720 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8721 {
8722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8723 if (SWIG_arg_fail(1)) SWIG_fail;
8724 if (arg1 == NULL) {
8725 SWIG_null_ref("wxTimer");
8726 }
8727 if (SWIG_arg_fail(1)) SWIG_fail;
8728 }
8729 {
8730 if (!wxPyCheckForApp()) SWIG_fail;
8731 PyThreadState* __tstate = wxPyBeginAllowThreads();
8732 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8733
8734 wxPyEndAllowThreads(__tstate);
8735 if (PyErr_Occurred()) SWIG_fail;
8736 }
8737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8738 return resultobj;
8739 fail:
8740 return NULL;
8741 }
8742
8743
8744 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8745 PyObject *resultobj;
8746 wxTimer *arg1 = 0 ;
8747 int arg2 ;
8748 bool arg3 = (bool) false ;
8749 wxTimerRunner *result;
8750 PyObject * obj0 = 0 ;
8751 PyObject * obj1 = 0 ;
8752 PyObject * obj2 = 0 ;
8753
8754 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8755 {
8756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8757 if (SWIG_arg_fail(1)) SWIG_fail;
8758 if (arg1 == NULL) {
8759 SWIG_null_ref("wxTimer");
8760 }
8761 if (SWIG_arg_fail(1)) SWIG_fail;
8762 }
8763 {
8764 arg2 = (int)(SWIG_As_int(obj1));
8765 if (SWIG_arg_fail(2)) SWIG_fail;
8766 }
8767 if (obj2) {
8768 {
8769 arg3 = (bool)(SWIG_As_bool(obj2));
8770 if (SWIG_arg_fail(3)) SWIG_fail;
8771 }
8772 }
8773 {
8774 if (!wxPyCheckForApp()) SWIG_fail;
8775 PyThreadState* __tstate = wxPyBeginAllowThreads();
8776 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8777
8778 wxPyEndAllowThreads(__tstate);
8779 if (PyErr_Occurred()) SWIG_fail;
8780 }
8781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8782 return resultobj;
8783 fail:
8784 return NULL;
8785 }
8786
8787
8788 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8789 int argc;
8790 PyObject *argv[4];
8791 int ii;
8792
8793 argc = PyObject_Length(args);
8794 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8795 argv[ii] = PyTuple_GetItem(args,ii);
8796 }
8797 if (argc == 1) {
8798 int _v;
8799 {
8800 void *ptr = 0;
8801 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8802 _v = 0;
8803 PyErr_Clear();
8804 } else {
8805 _v = (ptr != 0);
8806 }
8807 }
8808 if (_v) {
8809 return _wrap_new_TimerRunner__SWIG_0(self,args);
8810 }
8811 }
8812 if ((argc >= 2) && (argc <= 3)) {
8813 int _v;
8814 {
8815 void *ptr = 0;
8816 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8817 _v = 0;
8818 PyErr_Clear();
8819 } else {
8820 _v = (ptr != 0);
8821 }
8822 }
8823 if (_v) {
8824 _v = SWIG_Check_int(argv[1]);
8825 if (_v) {
8826 if (argc <= 2) {
8827 return _wrap_new_TimerRunner__SWIG_1(self,args);
8828 }
8829 _v = SWIG_Check_bool(argv[2]);
8830 if (_v) {
8831 return _wrap_new_TimerRunner__SWIG_1(self,args);
8832 }
8833 }
8834 }
8835 }
8836
8837 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8838 return NULL;
8839 }
8840
8841
8842 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8843 PyObject *resultobj;
8844 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8845 PyObject * obj0 = 0 ;
8846 char *kwnames[] = {
8847 (char *) "self", NULL
8848 };
8849
8850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8852 if (SWIG_arg_fail(1)) SWIG_fail;
8853 {
8854 PyThreadState* __tstate = wxPyBeginAllowThreads();
8855 delete arg1;
8856
8857 wxPyEndAllowThreads(__tstate);
8858 if (PyErr_Occurred()) SWIG_fail;
8859 }
8860 Py_INCREF(Py_None); resultobj = Py_None;
8861 return resultobj;
8862 fail:
8863 return NULL;
8864 }
8865
8866
8867 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8868 PyObject *resultobj;
8869 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8870 int arg2 ;
8871 bool arg3 = (bool) false ;
8872 PyObject * obj0 = 0 ;
8873 PyObject * obj1 = 0 ;
8874 PyObject * obj2 = 0 ;
8875 char *kwnames[] = {
8876 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8877 };
8878
8879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8881 if (SWIG_arg_fail(1)) SWIG_fail;
8882 {
8883 arg2 = (int)(SWIG_As_int(obj1));
8884 if (SWIG_arg_fail(2)) SWIG_fail;
8885 }
8886 if (obj2) {
8887 {
8888 arg3 = (bool)(SWIG_As_bool(obj2));
8889 if (SWIG_arg_fail(3)) SWIG_fail;
8890 }
8891 }
8892 {
8893 PyThreadState* __tstate = wxPyBeginAllowThreads();
8894 (arg1)->Start(arg2,arg3);
8895
8896 wxPyEndAllowThreads(__tstate);
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 Py_INCREF(Py_None); resultobj = Py_None;
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8907 PyObject *obj;
8908 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8909 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8910 Py_INCREF(obj);
8911 return Py_BuildValue((char *)"");
8912 }
8913 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8914 PyObject *resultobj;
8915 wxLog *result;
8916 char *kwnames[] = {
8917 NULL
8918 };
8919
8920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8921 {
8922 PyThreadState* __tstate = wxPyBeginAllowThreads();
8923 result = (wxLog *)new wxLog();
8924
8925 wxPyEndAllowThreads(__tstate);
8926 if (PyErr_Occurred()) SWIG_fail;
8927 }
8928 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8929 return resultobj;
8930 fail:
8931 return NULL;
8932 }
8933
8934
8935 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8936 PyObject *resultobj;
8937 bool result;
8938 char *kwnames[] = {
8939 NULL
8940 };
8941
8942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 result = (bool)wxLog::IsEnabled();
8946
8947 wxPyEndAllowThreads(__tstate);
8948 if (PyErr_Occurred()) SWIG_fail;
8949 }
8950 {
8951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8952 }
8953 return resultobj;
8954 fail:
8955 return NULL;
8956 }
8957
8958
8959 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8960 PyObject *resultobj;
8961 bool arg1 = (bool) true ;
8962 bool result;
8963 PyObject * obj0 = 0 ;
8964 char *kwnames[] = {
8965 (char *) "doIt", NULL
8966 };
8967
8968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8969 if (obj0) {
8970 {
8971 arg1 = (bool)(SWIG_As_bool(obj0));
8972 if (SWIG_arg_fail(1)) SWIG_fail;
8973 }
8974 }
8975 {
8976 PyThreadState* __tstate = wxPyBeginAllowThreads();
8977 result = (bool)wxLog::EnableLogging(arg1);
8978
8979 wxPyEndAllowThreads(__tstate);
8980 if (PyErr_Occurred()) SWIG_fail;
8981 }
8982 {
8983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8984 }
8985 return resultobj;
8986 fail:
8987 return NULL;
8988 }
8989
8990
8991 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8992 PyObject *resultobj;
8993 wxLogLevel arg1 ;
8994 wxChar *arg2 = (wxChar *) 0 ;
8995 time_t arg3 ;
8996 PyObject * obj0 = 0 ;
8997 PyObject * obj1 = 0 ;
8998 PyObject * obj2 = 0 ;
8999 char *kwnames[] = {
9000 (char *) "level",(char *) "szString",(char *) "t", NULL
9001 };
9002
9003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
9004 {
9005 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9006 if (SWIG_arg_fail(1)) SWIG_fail;
9007 }
9008 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9009 if (SWIG_arg_fail(2)) SWIG_fail;
9010 {
9011 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
9012 if (SWIG_arg_fail(3)) SWIG_fail;
9013 }
9014 {
9015 PyThreadState* __tstate = wxPyBeginAllowThreads();
9016 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
9017
9018 wxPyEndAllowThreads(__tstate);
9019 if (PyErr_Occurred()) SWIG_fail;
9020 }
9021 Py_INCREF(Py_None); resultobj = Py_None;
9022 return resultobj;
9023 fail:
9024 return NULL;
9025 }
9026
9027
9028 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
9029 PyObject *resultobj;
9030 wxLog *arg1 = (wxLog *) 0 ;
9031 PyObject * obj0 = 0 ;
9032 char *kwnames[] = {
9033 (char *) "self", NULL
9034 };
9035
9036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
9037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9038 if (SWIG_arg_fail(1)) SWIG_fail;
9039 {
9040 PyThreadState* __tstate = wxPyBeginAllowThreads();
9041 (arg1)->Flush();
9042
9043 wxPyEndAllowThreads(__tstate);
9044 if (PyErr_Occurred()) SWIG_fail;
9045 }
9046 Py_INCREF(Py_None); resultobj = Py_None;
9047 return resultobj;
9048 fail:
9049 return NULL;
9050 }
9051
9052
9053 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9054 PyObject *resultobj;
9055 char *kwnames[] = {
9056 NULL
9057 };
9058
9059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9060 {
9061 PyThreadState* __tstate = wxPyBeginAllowThreads();
9062 wxLog::FlushActive();
9063
9064 wxPyEndAllowThreads(__tstate);
9065 if (PyErr_Occurred()) SWIG_fail;
9066 }
9067 Py_INCREF(Py_None); resultobj = Py_None;
9068 return resultobj;
9069 fail:
9070 return NULL;
9071 }
9072
9073
9074 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9075 PyObject *resultobj;
9076 wxLog *result;
9077 char *kwnames[] = {
9078 NULL
9079 };
9080
9081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9082 {
9083 PyThreadState* __tstate = wxPyBeginAllowThreads();
9084 result = (wxLog *)wxLog::GetActiveTarget();
9085
9086 wxPyEndAllowThreads(__tstate);
9087 if (PyErr_Occurred()) SWIG_fail;
9088 }
9089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9090 return resultobj;
9091 fail:
9092 return NULL;
9093 }
9094
9095
9096 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9097 PyObject *resultobj;
9098 wxLog *arg1 = (wxLog *) 0 ;
9099 wxLog *result;
9100 PyObject * obj0 = 0 ;
9101 char *kwnames[] = {
9102 (char *) "pLogger", NULL
9103 };
9104
9105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9107 if (SWIG_arg_fail(1)) SWIG_fail;
9108 {
9109 PyThreadState* __tstate = wxPyBeginAllowThreads();
9110 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9111
9112 wxPyEndAllowThreads(__tstate);
9113 if (PyErr_Occurred()) SWIG_fail;
9114 }
9115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9116 return resultobj;
9117 fail:
9118 return NULL;
9119 }
9120
9121
9122 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9123 PyObject *resultobj;
9124 char *kwnames[] = {
9125 NULL
9126 };
9127
9128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9129 {
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 wxLog::Suspend();
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_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9144 PyObject *resultobj;
9145 char *kwnames[] = {
9146 NULL
9147 };
9148
9149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9150 {
9151 PyThreadState* __tstate = wxPyBeginAllowThreads();
9152 wxLog::Resume();
9153
9154 wxPyEndAllowThreads(__tstate);
9155 if (PyErr_Occurred()) SWIG_fail;
9156 }
9157 Py_INCREF(Py_None); resultobj = Py_None;
9158 return resultobj;
9159 fail:
9160 return NULL;
9161 }
9162
9163
9164 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9165 PyObject *resultobj;
9166 bool arg1 = (bool) true ;
9167 PyObject * obj0 = 0 ;
9168 char *kwnames[] = {
9169 (char *) "bVerbose", NULL
9170 };
9171
9172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9173 if (obj0) {
9174 {
9175 arg1 = (bool)(SWIG_As_bool(obj0));
9176 if (SWIG_arg_fail(1)) SWIG_fail;
9177 }
9178 }
9179 {
9180 PyThreadState* __tstate = wxPyBeginAllowThreads();
9181 wxLog::SetVerbose(arg1);
9182
9183 wxPyEndAllowThreads(__tstate);
9184 if (PyErr_Occurred()) SWIG_fail;
9185 }
9186 Py_INCREF(Py_None); resultobj = Py_None;
9187 return resultobj;
9188 fail:
9189 return NULL;
9190 }
9191
9192
9193 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9194 PyObject *resultobj;
9195 wxLogLevel arg1 ;
9196 PyObject * obj0 = 0 ;
9197 char *kwnames[] = {
9198 (char *) "logLevel", NULL
9199 };
9200
9201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9202 {
9203 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9204 if (SWIG_arg_fail(1)) SWIG_fail;
9205 }
9206 {
9207 PyThreadState* __tstate = wxPyBeginAllowThreads();
9208 wxLog::SetLogLevel(arg1);
9209
9210 wxPyEndAllowThreads(__tstate);
9211 if (PyErr_Occurred()) SWIG_fail;
9212 }
9213 Py_INCREF(Py_None); resultobj = Py_None;
9214 return resultobj;
9215 fail:
9216 return NULL;
9217 }
9218
9219
9220 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9221 PyObject *resultobj;
9222 char *kwnames[] = {
9223 NULL
9224 };
9225
9226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9227 {
9228 PyThreadState* __tstate = wxPyBeginAllowThreads();
9229 wxLog::DontCreateOnDemand();
9230
9231 wxPyEndAllowThreads(__tstate);
9232 if (PyErr_Occurred()) SWIG_fail;
9233 }
9234 Py_INCREF(Py_None); resultobj = Py_None;
9235 return resultobj;
9236 fail:
9237 return NULL;
9238 }
9239
9240
9241 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9242 PyObject *resultobj;
9243 wxTraceMask arg1 ;
9244 PyObject * obj0 = 0 ;
9245 char *kwnames[] = {
9246 (char *) "ulMask", NULL
9247 };
9248
9249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9250 {
9251 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9252 if (SWIG_arg_fail(1)) SWIG_fail;
9253 }
9254 {
9255 PyThreadState* __tstate = wxPyBeginAllowThreads();
9256 wxLog::SetTraceMask(arg1);
9257
9258 wxPyEndAllowThreads(__tstate);
9259 if (PyErr_Occurred()) SWIG_fail;
9260 }
9261 Py_INCREF(Py_None); resultobj = Py_None;
9262 return resultobj;
9263 fail:
9264 return NULL;
9265 }
9266
9267
9268 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9269 PyObject *resultobj;
9270 wxString *arg1 = 0 ;
9271 bool temp1 = false ;
9272 PyObject * obj0 = 0 ;
9273 char *kwnames[] = {
9274 (char *) "str", NULL
9275 };
9276
9277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9278 {
9279 arg1 = wxString_in_helper(obj0);
9280 if (arg1 == NULL) SWIG_fail;
9281 temp1 = true;
9282 }
9283 {
9284 PyThreadState* __tstate = wxPyBeginAllowThreads();
9285 wxLog::AddTraceMask((wxString const &)*arg1);
9286
9287 wxPyEndAllowThreads(__tstate);
9288 if (PyErr_Occurred()) SWIG_fail;
9289 }
9290 Py_INCREF(Py_None); resultobj = Py_None;
9291 {
9292 if (temp1)
9293 delete arg1;
9294 }
9295 return resultobj;
9296 fail:
9297 {
9298 if (temp1)
9299 delete arg1;
9300 }
9301 return NULL;
9302 }
9303
9304
9305 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9306 PyObject *resultobj;
9307 wxString *arg1 = 0 ;
9308 bool temp1 = false ;
9309 PyObject * obj0 = 0 ;
9310 char *kwnames[] = {
9311 (char *) "str", NULL
9312 };
9313
9314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9315 {
9316 arg1 = wxString_in_helper(obj0);
9317 if (arg1 == NULL) SWIG_fail;
9318 temp1 = true;
9319 }
9320 {
9321 PyThreadState* __tstate = wxPyBeginAllowThreads();
9322 wxLog::RemoveTraceMask((wxString const &)*arg1);
9323
9324 wxPyEndAllowThreads(__tstate);
9325 if (PyErr_Occurred()) SWIG_fail;
9326 }
9327 Py_INCREF(Py_None); resultobj = Py_None;
9328 {
9329 if (temp1)
9330 delete arg1;
9331 }
9332 return resultobj;
9333 fail:
9334 {
9335 if (temp1)
9336 delete arg1;
9337 }
9338 return NULL;
9339 }
9340
9341
9342 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9343 PyObject *resultobj;
9344 char *kwnames[] = {
9345 NULL
9346 };
9347
9348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9349 {
9350 PyThreadState* __tstate = wxPyBeginAllowThreads();
9351 wxLog::ClearTraceMasks();
9352
9353 wxPyEndAllowThreads(__tstate);
9354 if (PyErr_Occurred()) SWIG_fail;
9355 }
9356 Py_INCREF(Py_None); resultobj = Py_None;
9357 return resultobj;
9358 fail:
9359 return NULL;
9360 }
9361
9362
9363 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9364 PyObject *resultobj;
9365 wxArrayString *result;
9366 char *kwnames[] = {
9367 NULL
9368 };
9369
9370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9371 {
9372 PyThreadState* __tstate = wxPyBeginAllowThreads();
9373 {
9374 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9375 result = (wxArrayString *) &_result_ref;
9376 }
9377
9378 wxPyEndAllowThreads(__tstate);
9379 if (PyErr_Occurred()) SWIG_fail;
9380 }
9381 {
9382 resultobj = wxArrayString2PyList_helper(*result);
9383 }
9384 return resultobj;
9385 fail:
9386 return NULL;
9387 }
9388
9389
9390 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9391 PyObject *resultobj;
9392 wxChar *arg1 = (wxChar *) 0 ;
9393 PyObject * obj0 = 0 ;
9394 char *kwnames[] = {
9395 (char *) "ts", NULL
9396 };
9397
9398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9400 if (SWIG_arg_fail(1)) SWIG_fail;
9401 {
9402 PyThreadState* __tstate = wxPyBeginAllowThreads();
9403 wxLog::SetTimestamp((wxChar const *)arg1);
9404
9405 wxPyEndAllowThreads(__tstate);
9406 if (PyErr_Occurred()) SWIG_fail;
9407 }
9408 Py_INCREF(Py_None); resultobj = Py_None;
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9416 PyObject *resultobj;
9417 bool result;
9418 char *kwnames[] = {
9419 NULL
9420 };
9421
9422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9423 {
9424 PyThreadState* __tstate = wxPyBeginAllowThreads();
9425 result = (bool)wxLog::GetVerbose();
9426
9427 wxPyEndAllowThreads(__tstate);
9428 if (PyErr_Occurred()) SWIG_fail;
9429 }
9430 {
9431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9432 }
9433 return resultobj;
9434 fail:
9435 return NULL;
9436 }
9437
9438
9439 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9440 PyObject *resultobj;
9441 wxTraceMask result;
9442 char *kwnames[] = {
9443 NULL
9444 };
9445
9446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9447 {
9448 PyThreadState* __tstate = wxPyBeginAllowThreads();
9449 result = (wxTraceMask)wxLog::GetTraceMask();
9450
9451 wxPyEndAllowThreads(__tstate);
9452 if (PyErr_Occurred()) SWIG_fail;
9453 }
9454 {
9455 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9456 }
9457 return resultobj;
9458 fail:
9459 return NULL;
9460 }
9461
9462
9463 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9464 PyObject *resultobj;
9465 wxChar *arg1 = (wxChar *) 0 ;
9466 bool result;
9467 PyObject * obj0 = 0 ;
9468 char *kwnames[] = {
9469 (char *) "mask", NULL
9470 };
9471
9472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9474 if (SWIG_arg_fail(1)) SWIG_fail;
9475 {
9476 PyThreadState* __tstate = wxPyBeginAllowThreads();
9477 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9478
9479 wxPyEndAllowThreads(__tstate);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 {
9483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9484 }
9485 return resultobj;
9486 fail:
9487 return NULL;
9488 }
9489
9490
9491 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9492 PyObject *resultobj;
9493 wxLogLevel result;
9494 char *kwnames[] = {
9495 NULL
9496 };
9497
9498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9499 {
9500 PyThreadState* __tstate = wxPyBeginAllowThreads();
9501 result = (wxLogLevel)wxLog::GetLogLevel();
9502
9503 wxPyEndAllowThreads(__tstate);
9504 if (PyErr_Occurred()) SWIG_fail;
9505 }
9506 {
9507 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9508 }
9509 return resultobj;
9510 fail:
9511 return NULL;
9512 }
9513
9514
9515 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9516 PyObject *resultobj;
9517 wxChar *result;
9518 char *kwnames[] = {
9519 NULL
9520 };
9521
9522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9523 {
9524 PyThreadState* __tstate = wxPyBeginAllowThreads();
9525 result = (wxChar *)wxLog::GetTimestamp();
9526
9527 wxPyEndAllowThreads(__tstate);
9528 if (PyErr_Occurred()) SWIG_fail;
9529 }
9530 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9531 return resultobj;
9532 fail:
9533 return NULL;
9534 }
9535
9536
9537 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9538 PyObject *resultobj;
9539 wxString result;
9540 char *kwnames[] = {
9541 NULL
9542 };
9543
9544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9545 {
9546 PyThreadState* __tstate = wxPyBeginAllowThreads();
9547 result = Log_TimeStamp();
9548
9549 wxPyEndAllowThreads(__tstate);
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 {
9553 #if wxUSE_UNICODE
9554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9555 #else
9556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9557 #endif
9558 }
9559 return resultobj;
9560 fail:
9561 return NULL;
9562 }
9563
9564
9565 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9566 PyObject *resultobj;
9567 wxLog *arg1 = (wxLog *) 0 ;
9568 PyObject * obj0 = 0 ;
9569 char *kwnames[] = {
9570 (char *) "self", NULL
9571 };
9572
9573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9575 if (SWIG_arg_fail(1)) SWIG_fail;
9576 {
9577 PyThreadState* __tstate = wxPyBeginAllowThreads();
9578 wxLog_Destroy(arg1);
9579
9580 wxPyEndAllowThreads(__tstate);
9581 if (PyErr_Occurred()) SWIG_fail;
9582 }
9583 Py_INCREF(Py_None); resultobj = Py_None;
9584 return resultobj;
9585 fail:
9586 return NULL;
9587 }
9588
9589
9590 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9591 PyObject *obj;
9592 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9593 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9594 Py_INCREF(obj);
9595 return Py_BuildValue((char *)"");
9596 }
9597 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9598 PyObject *resultobj;
9599 wxLogStderr *result;
9600 char *kwnames[] = {
9601 NULL
9602 };
9603
9604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9605 {
9606 PyThreadState* __tstate = wxPyBeginAllowThreads();
9607 result = (wxLogStderr *)new wxLogStderr();
9608
9609 wxPyEndAllowThreads(__tstate);
9610 if (PyErr_Occurred()) SWIG_fail;
9611 }
9612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9613 return resultobj;
9614 fail:
9615 return NULL;
9616 }
9617
9618
9619 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9620 PyObject *obj;
9621 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9622 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9623 Py_INCREF(obj);
9624 return Py_BuildValue((char *)"");
9625 }
9626 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9627 PyObject *resultobj;
9628 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9629 wxLogTextCtrl *result;
9630 PyObject * obj0 = 0 ;
9631 char *kwnames[] = {
9632 (char *) "pTextCtrl", NULL
9633 };
9634
9635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9637 if (SWIG_arg_fail(1)) SWIG_fail;
9638 {
9639 PyThreadState* __tstate = wxPyBeginAllowThreads();
9640 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9641
9642 wxPyEndAllowThreads(__tstate);
9643 if (PyErr_Occurred()) SWIG_fail;
9644 }
9645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9646 return resultobj;
9647 fail:
9648 return NULL;
9649 }
9650
9651
9652 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9653 PyObject *obj;
9654 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9655 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9656 Py_INCREF(obj);
9657 return Py_BuildValue((char *)"");
9658 }
9659 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9660 PyObject *resultobj;
9661 wxLogGui *result;
9662 char *kwnames[] = {
9663 NULL
9664 };
9665
9666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9667 {
9668 PyThreadState* __tstate = wxPyBeginAllowThreads();
9669 result = (wxLogGui *)new wxLogGui();
9670
9671 wxPyEndAllowThreads(__tstate);
9672 if (PyErr_Occurred()) SWIG_fail;
9673 }
9674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9675 return resultobj;
9676 fail:
9677 return NULL;
9678 }
9679
9680
9681 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9682 PyObject *obj;
9683 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9684 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9685 Py_INCREF(obj);
9686 return Py_BuildValue((char *)"");
9687 }
9688 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9689 PyObject *resultobj;
9690 wxFrame *arg1 = (wxFrame *) 0 ;
9691 wxString *arg2 = 0 ;
9692 bool arg3 = (bool) true ;
9693 bool arg4 = (bool) true ;
9694 wxLogWindow *result;
9695 bool temp2 = false ;
9696 PyObject * obj0 = 0 ;
9697 PyObject * obj1 = 0 ;
9698 PyObject * obj2 = 0 ;
9699 PyObject * obj3 = 0 ;
9700 char *kwnames[] = {
9701 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9702 };
9703
9704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9706 if (SWIG_arg_fail(1)) SWIG_fail;
9707 {
9708 arg2 = wxString_in_helper(obj1);
9709 if (arg2 == NULL) SWIG_fail;
9710 temp2 = true;
9711 }
9712 if (obj2) {
9713 {
9714 arg3 = (bool)(SWIG_As_bool(obj2));
9715 if (SWIG_arg_fail(3)) SWIG_fail;
9716 }
9717 }
9718 if (obj3) {
9719 {
9720 arg4 = (bool)(SWIG_As_bool(obj3));
9721 if (SWIG_arg_fail(4)) SWIG_fail;
9722 }
9723 }
9724 {
9725 PyThreadState* __tstate = wxPyBeginAllowThreads();
9726 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9727
9728 wxPyEndAllowThreads(__tstate);
9729 if (PyErr_Occurred()) SWIG_fail;
9730 }
9731 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9732 {
9733 if (temp2)
9734 delete arg2;
9735 }
9736 return resultobj;
9737 fail:
9738 {
9739 if (temp2)
9740 delete arg2;
9741 }
9742 return NULL;
9743 }
9744
9745
9746 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9747 PyObject *resultobj;
9748 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9749 bool arg2 = (bool) true ;
9750 PyObject * obj0 = 0 ;
9751 PyObject * obj1 = 0 ;
9752 char *kwnames[] = {
9753 (char *) "self",(char *) "bShow", NULL
9754 };
9755
9756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9758 if (SWIG_arg_fail(1)) SWIG_fail;
9759 if (obj1) {
9760 {
9761 arg2 = (bool)(SWIG_As_bool(obj1));
9762 if (SWIG_arg_fail(2)) SWIG_fail;
9763 }
9764 }
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 (arg1)->Show(arg2);
9768
9769 wxPyEndAllowThreads(__tstate);
9770 if (PyErr_Occurred()) SWIG_fail;
9771 }
9772 Py_INCREF(Py_None); resultobj = Py_None;
9773 return resultobj;
9774 fail:
9775 return NULL;
9776 }
9777
9778
9779 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9780 PyObject *resultobj;
9781 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9782 wxFrame *result;
9783 PyObject * obj0 = 0 ;
9784 char *kwnames[] = {
9785 (char *) "self", NULL
9786 };
9787
9788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9790 if (SWIG_arg_fail(1)) SWIG_fail;
9791 {
9792 PyThreadState* __tstate = wxPyBeginAllowThreads();
9793 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9794
9795 wxPyEndAllowThreads(__tstate);
9796 if (PyErr_Occurred()) SWIG_fail;
9797 }
9798 {
9799 resultobj = wxPyMake_wxObject(result, 0);
9800 }
9801 return resultobj;
9802 fail:
9803 return NULL;
9804 }
9805
9806
9807 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9808 PyObject *resultobj;
9809 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9810 wxLog *result;
9811 PyObject * obj0 = 0 ;
9812 char *kwnames[] = {
9813 (char *) "self", NULL
9814 };
9815
9816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9818 if (SWIG_arg_fail(1)) SWIG_fail;
9819 {
9820 PyThreadState* __tstate = wxPyBeginAllowThreads();
9821 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9822
9823 wxPyEndAllowThreads(__tstate);
9824 if (PyErr_Occurred()) SWIG_fail;
9825 }
9826 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9827 return resultobj;
9828 fail:
9829 return NULL;
9830 }
9831
9832
9833 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9834 PyObject *resultobj;
9835 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9836 bool result;
9837 PyObject * obj0 = 0 ;
9838 char *kwnames[] = {
9839 (char *) "self", NULL
9840 };
9841
9842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9844 if (SWIG_arg_fail(1)) SWIG_fail;
9845 {
9846 PyThreadState* __tstate = wxPyBeginAllowThreads();
9847 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9848
9849 wxPyEndAllowThreads(__tstate);
9850 if (PyErr_Occurred()) SWIG_fail;
9851 }
9852 {
9853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9854 }
9855 return resultobj;
9856 fail:
9857 return NULL;
9858 }
9859
9860
9861 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9862 PyObject *resultobj;
9863 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9864 bool arg2 ;
9865 PyObject * obj0 = 0 ;
9866 PyObject * obj1 = 0 ;
9867 char *kwnames[] = {
9868 (char *) "self",(char *) "bDoPass", NULL
9869 };
9870
9871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9873 if (SWIG_arg_fail(1)) SWIG_fail;
9874 {
9875 arg2 = (bool)(SWIG_As_bool(obj1));
9876 if (SWIG_arg_fail(2)) SWIG_fail;
9877 }
9878 {
9879 PyThreadState* __tstate = wxPyBeginAllowThreads();
9880 (arg1)->PassMessages(arg2);
9881
9882 wxPyEndAllowThreads(__tstate);
9883 if (PyErr_Occurred()) SWIG_fail;
9884 }
9885 Py_INCREF(Py_None); resultobj = Py_None;
9886 return resultobj;
9887 fail:
9888 return NULL;
9889 }
9890
9891
9892 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9893 PyObject *obj;
9894 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9895 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9896 Py_INCREF(obj);
9897 return Py_BuildValue((char *)"");
9898 }
9899 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9900 PyObject *resultobj;
9901 wxLog *arg1 = (wxLog *) 0 ;
9902 wxLogChain *result;
9903 PyObject * obj0 = 0 ;
9904 char *kwnames[] = {
9905 (char *) "logger", NULL
9906 };
9907
9908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9910 if (SWIG_arg_fail(1)) SWIG_fail;
9911 {
9912 PyThreadState* __tstate = wxPyBeginAllowThreads();
9913 result = (wxLogChain *)new wxLogChain(arg1);
9914
9915 wxPyEndAllowThreads(__tstate);
9916 if (PyErr_Occurred()) SWIG_fail;
9917 }
9918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9919 return resultobj;
9920 fail:
9921 return NULL;
9922 }
9923
9924
9925 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9926 PyObject *resultobj;
9927 wxLogChain *arg1 = (wxLogChain *) 0 ;
9928 wxLog *arg2 = (wxLog *) 0 ;
9929 PyObject * obj0 = 0 ;
9930 PyObject * obj1 = 0 ;
9931 char *kwnames[] = {
9932 (char *) "self",(char *) "logger", NULL
9933 };
9934
9935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9937 if (SWIG_arg_fail(1)) SWIG_fail;
9938 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9939 if (SWIG_arg_fail(2)) SWIG_fail;
9940 {
9941 PyThreadState* __tstate = wxPyBeginAllowThreads();
9942 (arg1)->SetLog(arg2);
9943
9944 wxPyEndAllowThreads(__tstate);
9945 if (PyErr_Occurred()) SWIG_fail;
9946 }
9947 Py_INCREF(Py_None); resultobj = Py_None;
9948 return resultobj;
9949 fail:
9950 return NULL;
9951 }
9952
9953
9954 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9955 PyObject *resultobj;
9956 wxLogChain *arg1 = (wxLogChain *) 0 ;
9957 bool arg2 ;
9958 PyObject * obj0 = 0 ;
9959 PyObject * obj1 = 0 ;
9960 char *kwnames[] = {
9961 (char *) "self",(char *) "bDoPass", NULL
9962 };
9963
9964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9966 if (SWIG_arg_fail(1)) SWIG_fail;
9967 {
9968 arg2 = (bool)(SWIG_As_bool(obj1));
9969 if (SWIG_arg_fail(2)) SWIG_fail;
9970 }
9971 {
9972 PyThreadState* __tstate = wxPyBeginAllowThreads();
9973 (arg1)->PassMessages(arg2);
9974
9975 wxPyEndAllowThreads(__tstate);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 Py_INCREF(Py_None); resultobj = Py_None;
9979 return resultobj;
9980 fail:
9981 return NULL;
9982 }
9983
9984
9985 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9986 PyObject *resultobj;
9987 wxLogChain *arg1 = (wxLogChain *) 0 ;
9988 bool result;
9989 PyObject * obj0 = 0 ;
9990 char *kwnames[] = {
9991 (char *) "self", NULL
9992 };
9993
9994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9996 if (SWIG_arg_fail(1)) SWIG_fail;
9997 {
9998 PyThreadState* __tstate = wxPyBeginAllowThreads();
9999 result = (bool)(arg1)->IsPassingMessages();
10000
10001 wxPyEndAllowThreads(__tstate);
10002 if (PyErr_Occurred()) SWIG_fail;
10003 }
10004 {
10005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10006 }
10007 return resultobj;
10008 fail:
10009 return NULL;
10010 }
10011
10012
10013 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10014 PyObject *resultobj;
10015 wxLogChain *arg1 = (wxLogChain *) 0 ;
10016 wxLog *result;
10017 PyObject * obj0 = 0 ;
10018 char *kwnames[] = {
10019 (char *) "self", NULL
10020 };
10021
10022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
10023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10024 if (SWIG_arg_fail(1)) SWIG_fail;
10025 {
10026 PyThreadState* __tstate = wxPyBeginAllowThreads();
10027 result = (wxLog *)(arg1)->GetOldLog();
10028
10029 wxPyEndAllowThreads(__tstate);
10030 if (PyErr_Occurred()) SWIG_fail;
10031 }
10032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10033 return resultobj;
10034 fail:
10035 return NULL;
10036 }
10037
10038
10039 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
10040 PyObject *obj;
10041 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10042 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10043 Py_INCREF(obj);
10044 return Py_BuildValue((char *)"");
10045 }
10046 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10047 PyObject *resultobj;
10048 unsigned long result;
10049 char *kwnames[] = {
10050 NULL
10051 };
10052
10053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10054 {
10055 PyThreadState* __tstate = wxPyBeginAllowThreads();
10056 result = (unsigned long)wxSysErrorCode();
10057
10058 wxPyEndAllowThreads(__tstate);
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 {
10062 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10063 }
10064 return resultobj;
10065 fail:
10066 return NULL;
10067 }
10068
10069
10070 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10071 PyObject *resultobj;
10072 unsigned long arg1 = (unsigned long) 0 ;
10073 wxString result;
10074 PyObject * obj0 = 0 ;
10075 char *kwnames[] = {
10076 (char *) "nErrCode", NULL
10077 };
10078
10079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10080 if (obj0) {
10081 {
10082 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10083 if (SWIG_arg_fail(1)) SWIG_fail;
10084 }
10085 }
10086 {
10087 PyThreadState* __tstate = wxPyBeginAllowThreads();
10088 result = wxSysErrorMsg(arg1);
10089
10090 wxPyEndAllowThreads(__tstate);
10091 if (PyErr_Occurred()) SWIG_fail;
10092 }
10093 {
10094 #if wxUSE_UNICODE
10095 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10096 #else
10097 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10098 #endif
10099 }
10100 return resultobj;
10101 fail:
10102 return NULL;
10103 }
10104
10105
10106 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10107 PyObject *resultobj;
10108 wxString *arg1 = 0 ;
10109 bool temp1 = false ;
10110 PyObject * obj0 = 0 ;
10111 char *kwnames[] = {
10112 (char *) "msg", NULL
10113 };
10114
10115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10116 {
10117 arg1 = wxString_in_helper(obj0);
10118 if (arg1 == NULL) SWIG_fail;
10119 temp1 = true;
10120 }
10121 {
10122 PyThreadState* __tstate = wxPyBeginAllowThreads();
10123 wxPyLogFatalError((wxString const &)*arg1);
10124
10125 wxPyEndAllowThreads(__tstate);
10126 if (PyErr_Occurred()) SWIG_fail;
10127 }
10128 Py_INCREF(Py_None); resultobj = Py_None;
10129 {
10130 if (temp1)
10131 delete arg1;
10132 }
10133 return resultobj;
10134 fail:
10135 {
10136 if (temp1)
10137 delete arg1;
10138 }
10139 return NULL;
10140 }
10141
10142
10143 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10144 PyObject *resultobj;
10145 wxString *arg1 = 0 ;
10146 bool temp1 = false ;
10147 PyObject * obj0 = 0 ;
10148 char *kwnames[] = {
10149 (char *) "msg", NULL
10150 };
10151
10152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10153 {
10154 arg1 = wxString_in_helper(obj0);
10155 if (arg1 == NULL) SWIG_fail;
10156 temp1 = true;
10157 }
10158 {
10159 PyThreadState* __tstate = wxPyBeginAllowThreads();
10160 wxPyLogError((wxString const &)*arg1);
10161
10162 wxPyEndAllowThreads(__tstate);
10163 if (PyErr_Occurred()) SWIG_fail;
10164 }
10165 Py_INCREF(Py_None); resultobj = Py_None;
10166 {
10167 if (temp1)
10168 delete arg1;
10169 }
10170 return resultobj;
10171 fail:
10172 {
10173 if (temp1)
10174 delete arg1;
10175 }
10176 return NULL;
10177 }
10178
10179
10180 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10181 PyObject *resultobj;
10182 wxString *arg1 = 0 ;
10183 bool temp1 = false ;
10184 PyObject * obj0 = 0 ;
10185 char *kwnames[] = {
10186 (char *) "msg", NULL
10187 };
10188
10189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10190 {
10191 arg1 = wxString_in_helper(obj0);
10192 if (arg1 == NULL) SWIG_fail;
10193 temp1 = true;
10194 }
10195 {
10196 PyThreadState* __tstate = wxPyBeginAllowThreads();
10197 wxPyLogWarning((wxString const &)*arg1);
10198
10199 wxPyEndAllowThreads(__tstate);
10200 if (PyErr_Occurred()) SWIG_fail;
10201 }
10202 Py_INCREF(Py_None); resultobj = Py_None;
10203 {
10204 if (temp1)
10205 delete arg1;
10206 }
10207 return resultobj;
10208 fail:
10209 {
10210 if (temp1)
10211 delete arg1;
10212 }
10213 return NULL;
10214 }
10215
10216
10217 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10218 PyObject *resultobj;
10219 wxString *arg1 = 0 ;
10220 bool temp1 = false ;
10221 PyObject * obj0 = 0 ;
10222 char *kwnames[] = {
10223 (char *) "msg", NULL
10224 };
10225
10226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10227 {
10228 arg1 = wxString_in_helper(obj0);
10229 if (arg1 == NULL) SWIG_fail;
10230 temp1 = true;
10231 }
10232 {
10233 PyThreadState* __tstate = wxPyBeginAllowThreads();
10234 wxPyLogMessage((wxString const &)*arg1);
10235
10236 wxPyEndAllowThreads(__tstate);
10237 if (PyErr_Occurred()) SWIG_fail;
10238 }
10239 Py_INCREF(Py_None); resultobj = Py_None;
10240 {
10241 if (temp1)
10242 delete arg1;
10243 }
10244 return resultobj;
10245 fail:
10246 {
10247 if (temp1)
10248 delete arg1;
10249 }
10250 return NULL;
10251 }
10252
10253
10254 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10255 PyObject *resultobj;
10256 wxString *arg1 = 0 ;
10257 bool temp1 = false ;
10258 PyObject * obj0 = 0 ;
10259 char *kwnames[] = {
10260 (char *) "msg", NULL
10261 };
10262
10263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10264 {
10265 arg1 = wxString_in_helper(obj0);
10266 if (arg1 == NULL) SWIG_fail;
10267 temp1 = true;
10268 }
10269 {
10270 PyThreadState* __tstate = wxPyBeginAllowThreads();
10271 wxPyLogInfo((wxString const &)*arg1);
10272
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 Py_INCREF(Py_None); resultobj = Py_None;
10277 {
10278 if (temp1)
10279 delete arg1;
10280 }
10281 return resultobj;
10282 fail:
10283 {
10284 if (temp1)
10285 delete arg1;
10286 }
10287 return NULL;
10288 }
10289
10290
10291 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10292 PyObject *resultobj;
10293 wxString *arg1 = 0 ;
10294 bool temp1 = false ;
10295 PyObject * obj0 = 0 ;
10296 char *kwnames[] = {
10297 (char *) "msg", NULL
10298 };
10299
10300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10301 {
10302 arg1 = wxString_in_helper(obj0);
10303 if (arg1 == NULL) SWIG_fail;
10304 temp1 = true;
10305 }
10306 {
10307 PyThreadState* __tstate = wxPyBeginAllowThreads();
10308 wxPyLogDebug((wxString const &)*arg1);
10309
10310 wxPyEndAllowThreads(__tstate);
10311 if (PyErr_Occurred()) SWIG_fail;
10312 }
10313 Py_INCREF(Py_None); resultobj = Py_None;
10314 {
10315 if (temp1)
10316 delete arg1;
10317 }
10318 return resultobj;
10319 fail:
10320 {
10321 if (temp1)
10322 delete arg1;
10323 }
10324 return NULL;
10325 }
10326
10327
10328 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10329 PyObject *resultobj;
10330 wxString *arg1 = 0 ;
10331 bool temp1 = false ;
10332 PyObject * obj0 = 0 ;
10333 char *kwnames[] = {
10334 (char *) "msg", NULL
10335 };
10336
10337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10338 {
10339 arg1 = wxString_in_helper(obj0);
10340 if (arg1 == NULL) SWIG_fail;
10341 temp1 = true;
10342 }
10343 {
10344 PyThreadState* __tstate = wxPyBeginAllowThreads();
10345 wxPyLogVerbose((wxString const &)*arg1);
10346
10347 wxPyEndAllowThreads(__tstate);
10348 if (PyErr_Occurred()) SWIG_fail;
10349 }
10350 Py_INCREF(Py_None); resultobj = Py_None;
10351 {
10352 if (temp1)
10353 delete arg1;
10354 }
10355 return resultobj;
10356 fail:
10357 {
10358 if (temp1)
10359 delete arg1;
10360 }
10361 return NULL;
10362 }
10363
10364
10365 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10366 PyObject *resultobj;
10367 wxString *arg1 = 0 ;
10368 bool temp1 = false ;
10369 PyObject * obj0 = 0 ;
10370 char *kwnames[] = {
10371 (char *) "msg", NULL
10372 };
10373
10374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10375 {
10376 arg1 = wxString_in_helper(obj0);
10377 if (arg1 == NULL) SWIG_fail;
10378 temp1 = true;
10379 }
10380 {
10381 PyThreadState* __tstate = wxPyBeginAllowThreads();
10382 wxPyLogStatus((wxString const &)*arg1);
10383
10384 wxPyEndAllowThreads(__tstate);
10385 if (PyErr_Occurred()) SWIG_fail;
10386 }
10387 Py_INCREF(Py_None); resultobj = Py_None;
10388 {
10389 if (temp1)
10390 delete arg1;
10391 }
10392 return resultobj;
10393 fail:
10394 {
10395 if (temp1)
10396 delete arg1;
10397 }
10398 return NULL;
10399 }
10400
10401
10402 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10403 PyObject *resultobj;
10404 wxFrame *arg1 = (wxFrame *) 0 ;
10405 wxString *arg2 = 0 ;
10406 bool temp2 = false ;
10407 PyObject * obj0 = 0 ;
10408 PyObject * obj1 = 0 ;
10409 char *kwnames[] = {
10410 (char *) "pFrame",(char *) "msg", NULL
10411 };
10412
10413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10415 if (SWIG_arg_fail(1)) SWIG_fail;
10416 {
10417 arg2 = wxString_in_helper(obj1);
10418 if (arg2 == NULL) SWIG_fail;
10419 temp2 = true;
10420 }
10421 {
10422 PyThreadState* __tstate = wxPyBeginAllowThreads();
10423 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10424
10425 wxPyEndAllowThreads(__tstate);
10426 if (PyErr_Occurred()) SWIG_fail;
10427 }
10428 Py_INCREF(Py_None); resultobj = Py_None;
10429 {
10430 if (temp2)
10431 delete arg2;
10432 }
10433 return resultobj;
10434 fail:
10435 {
10436 if (temp2)
10437 delete arg2;
10438 }
10439 return NULL;
10440 }
10441
10442
10443 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10444 PyObject *resultobj;
10445 wxString *arg1 = 0 ;
10446 bool temp1 = false ;
10447 PyObject * obj0 = 0 ;
10448 char *kwnames[] = {
10449 (char *) "msg", NULL
10450 };
10451
10452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10453 {
10454 arg1 = wxString_in_helper(obj0);
10455 if (arg1 == NULL) SWIG_fail;
10456 temp1 = true;
10457 }
10458 {
10459 PyThreadState* __tstate = wxPyBeginAllowThreads();
10460 wxPyLogSysError((wxString const &)*arg1);
10461
10462 wxPyEndAllowThreads(__tstate);
10463 if (PyErr_Occurred()) SWIG_fail;
10464 }
10465 Py_INCREF(Py_None); resultobj = Py_None;
10466 {
10467 if (temp1)
10468 delete arg1;
10469 }
10470 return resultobj;
10471 fail:
10472 {
10473 if (temp1)
10474 delete arg1;
10475 }
10476 return NULL;
10477 }
10478
10479
10480 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10481 PyObject *resultobj;
10482 unsigned long arg1 ;
10483 wxString *arg2 = 0 ;
10484 bool temp2 = false ;
10485 PyObject * obj0 = 0 ;
10486 PyObject * obj1 = 0 ;
10487 char *kwnames[] = {
10488 (char *) "level",(char *) "msg", NULL
10489 };
10490
10491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10492 {
10493 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10494 if (SWIG_arg_fail(1)) SWIG_fail;
10495 }
10496 {
10497 arg2 = wxString_in_helper(obj1);
10498 if (arg2 == NULL) SWIG_fail;
10499 temp2 = true;
10500 }
10501 {
10502 PyThreadState* __tstate = wxPyBeginAllowThreads();
10503 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10504
10505 wxPyEndAllowThreads(__tstate);
10506 if (PyErr_Occurred()) SWIG_fail;
10507 }
10508 Py_INCREF(Py_None); resultobj = Py_None;
10509 {
10510 if (temp2)
10511 delete arg2;
10512 }
10513 return resultobj;
10514 fail:
10515 {
10516 if (temp2)
10517 delete arg2;
10518 }
10519 return NULL;
10520 }
10521
10522
10523 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10524 PyObject *resultobj;
10525 unsigned long arg1 ;
10526 wxString *arg2 = 0 ;
10527 bool temp2 = false ;
10528 PyObject * obj0 = 0 ;
10529 PyObject * obj1 = 0 ;
10530
10531 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10532 {
10533 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10534 if (SWIG_arg_fail(1)) SWIG_fail;
10535 }
10536 {
10537 arg2 = wxString_in_helper(obj1);
10538 if (arg2 == NULL) SWIG_fail;
10539 temp2 = true;
10540 }
10541 {
10542 PyThreadState* __tstate = wxPyBeginAllowThreads();
10543 wxPyLogTrace(arg1,(wxString const &)*arg2);
10544
10545 wxPyEndAllowThreads(__tstate);
10546 if (PyErr_Occurred()) SWIG_fail;
10547 }
10548 Py_INCREF(Py_None); resultobj = Py_None;
10549 {
10550 if (temp2)
10551 delete arg2;
10552 }
10553 return resultobj;
10554 fail:
10555 {
10556 if (temp2)
10557 delete arg2;
10558 }
10559 return NULL;
10560 }
10561
10562
10563 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10564 PyObject *resultobj;
10565 wxString *arg1 = 0 ;
10566 wxString *arg2 = 0 ;
10567 bool temp1 = false ;
10568 bool temp2 = false ;
10569 PyObject * obj0 = 0 ;
10570 PyObject * obj1 = 0 ;
10571
10572 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10573 {
10574 arg1 = wxString_in_helper(obj0);
10575 if (arg1 == NULL) SWIG_fail;
10576 temp1 = true;
10577 }
10578 {
10579 arg2 = wxString_in_helper(obj1);
10580 if (arg2 == NULL) SWIG_fail;
10581 temp2 = true;
10582 }
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10586
10587 wxPyEndAllowThreads(__tstate);
10588 if (PyErr_Occurred()) SWIG_fail;
10589 }
10590 Py_INCREF(Py_None); resultobj = Py_None;
10591 {
10592 if (temp1)
10593 delete arg1;
10594 }
10595 {
10596 if (temp2)
10597 delete arg2;
10598 }
10599 return resultobj;
10600 fail:
10601 {
10602 if (temp1)
10603 delete arg1;
10604 }
10605 {
10606 if (temp2)
10607 delete arg2;
10608 }
10609 return NULL;
10610 }
10611
10612
10613 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10614 int argc;
10615 PyObject *argv[3];
10616 int ii;
10617
10618 argc = PyObject_Length(args);
10619 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10620 argv[ii] = PyTuple_GetItem(args,ii);
10621 }
10622 if (argc == 2) {
10623 int _v;
10624 {
10625 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10626 }
10627 if (_v) {
10628 {
10629 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10630 }
10631 if (_v) {
10632 return _wrap_LogTrace__SWIG_1(self,args);
10633 }
10634 }
10635 }
10636 if (argc == 2) {
10637 int _v;
10638 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10639 if (_v) {
10640 {
10641 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10642 }
10643 if (_v) {
10644 return _wrap_LogTrace__SWIG_0(self,args);
10645 }
10646 }
10647 }
10648
10649 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10650 return NULL;
10651 }
10652
10653
10654 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10655 PyObject *resultobj;
10656 wxString *arg1 = 0 ;
10657 wxString *arg2 = 0 ;
10658 bool temp1 = false ;
10659 bool temp2 = false ;
10660 PyObject * obj0 = 0 ;
10661 PyObject * obj1 = 0 ;
10662 char *kwnames[] = {
10663 (char *) "title",(char *) "text", NULL
10664 };
10665
10666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10667 {
10668 arg1 = wxString_in_helper(obj0);
10669 if (arg1 == NULL) SWIG_fail;
10670 temp1 = true;
10671 }
10672 {
10673 arg2 = wxString_in_helper(obj1);
10674 if (arg2 == NULL) SWIG_fail;
10675 temp2 = true;
10676 }
10677 {
10678 PyThreadState* __tstate = wxPyBeginAllowThreads();
10679 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10680
10681 wxPyEndAllowThreads(__tstate);
10682 if (PyErr_Occurred()) SWIG_fail;
10683 }
10684 Py_INCREF(Py_None); resultobj = Py_None;
10685 {
10686 if (temp1)
10687 delete arg1;
10688 }
10689 {
10690 if (temp2)
10691 delete arg2;
10692 }
10693 return resultobj;
10694 fail:
10695 {
10696 if (temp1)
10697 delete arg1;
10698 }
10699 {
10700 if (temp2)
10701 delete arg2;
10702 }
10703 return NULL;
10704 }
10705
10706
10707 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10708 PyObject *resultobj;
10709 wxLogNull *result;
10710 char *kwnames[] = {
10711 NULL
10712 };
10713
10714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10715 {
10716 PyThreadState* __tstate = wxPyBeginAllowThreads();
10717 result = (wxLogNull *)new wxLogNull();
10718
10719 wxPyEndAllowThreads(__tstate);
10720 if (PyErr_Occurred()) SWIG_fail;
10721 }
10722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10723 return resultobj;
10724 fail:
10725 return NULL;
10726 }
10727
10728
10729 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10730 PyObject *resultobj;
10731 wxLogNull *arg1 = (wxLogNull *) 0 ;
10732 PyObject * obj0 = 0 ;
10733 char *kwnames[] = {
10734 (char *) "self", NULL
10735 };
10736
10737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10739 if (SWIG_arg_fail(1)) SWIG_fail;
10740 {
10741 PyThreadState* __tstate = wxPyBeginAllowThreads();
10742 delete arg1;
10743
10744 wxPyEndAllowThreads(__tstate);
10745 if (PyErr_Occurred()) SWIG_fail;
10746 }
10747 Py_INCREF(Py_None); resultobj = Py_None;
10748 return resultobj;
10749 fail:
10750 return NULL;
10751 }
10752
10753
10754 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10755 PyObject *obj;
10756 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10757 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10758 Py_INCREF(obj);
10759 return Py_BuildValue((char *)"");
10760 }
10761 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10762 PyObject *resultobj;
10763 wxPyLog *result;
10764 char *kwnames[] = {
10765 NULL
10766 };
10767
10768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10769 {
10770 PyThreadState* __tstate = wxPyBeginAllowThreads();
10771 result = (wxPyLog *)new wxPyLog();
10772
10773 wxPyEndAllowThreads(__tstate);
10774 if (PyErr_Occurred()) SWIG_fail;
10775 }
10776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10777 return resultobj;
10778 fail:
10779 return NULL;
10780 }
10781
10782
10783 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10784 PyObject *resultobj;
10785 wxPyLog *arg1 = (wxPyLog *) 0 ;
10786 PyObject *arg2 = (PyObject *) 0 ;
10787 PyObject *arg3 = (PyObject *) 0 ;
10788 PyObject * obj0 = 0 ;
10789 PyObject * obj1 = 0 ;
10790 PyObject * obj2 = 0 ;
10791 char *kwnames[] = {
10792 (char *) "self",(char *) "self",(char *) "_class", NULL
10793 };
10794
10795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10797 if (SWIG_arg_fail(1)) SWIG_fail;
10798 arg2 = obj1;
10799 arg3 = obj2;
10800 {
10801 PyThreadState* __tstate = wxPyBeginAllowThreads();
10802 (arg1)->_setCallbackInfo(arg2,arg3);
10803
10804 wxPyEndAllowThreads(__tstate);
10805 if (PyErr_Occurred()) SWIG_fail;
10806 }
10807 Py_INCREF(Py_None); resultobj = Py_None;
10808 return resultobj;
10809 fail:
10810 return NULL;
10811 }
10812
10813
10814 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10815 PyObject *obj;
10816 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10817 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10818 Py_INCREF(obj);
10819 return Py_BuildValue((char *)"");
10820 }
10821 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10822 PyObject *resultobj;
10823 int arg1 ;
10824 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10825 int arg3 = (int) wxKILL_NOCHILDREN ;
10826 wxKillError result;
10827 PyObject * obj0 = 0 ;
10828 PyObject * obj1 = 0 ;
10829 PyObject * obj2 = 0 ;
10830 char *kwnames[] = {
10831 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10832 };
10833
10834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10835 {
10836 arg1 = (int)(SWIG_As_int(obj0));
10837 if (SWIG_arg_fail(1)) SWIG_fail;
10838 }
10839 if (obj1) {
10840 {
10841 arg2 = (wxSignal)(SWIG_As_int(obj1));
10842 if (SWIG_arg_fail(2)) SWIG_fail;
10843 }
10844 }
10845 if (obj2) {
10846 {
10847 arg3 = (int)(SWIG_As_int(obj2));
10848 if (SWIG_arg_fail(3)) SWIG_fail;
10849 }
10850 }
10851 {
10852 PyThreadState* __tstate = wxPyBeginAllowThreads();
10853 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10854
10855 wxPyEndAllowThreads(__tstate);
10856 if (PyErr_Occurred()) SWIG_fail;
10857 }
10858 resultobj = SWIG_From_int((result));
10859 return resultobj;
10860 fail:
10861 return NULL;
10862 }
10863
10864
10865 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10866 PyObject *resultobj;
10867 int arg1 ;
10868 bool result;
10869 PyObject * obj0 = 0 ;
10870 char *kwnames[] = {
10871 (char *) "pid", NULL
10872 };
10873
10874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10875 {
10876 arg1 = (int)(SWIG_As_int(obj0));
10877 if (SWIG_arg_fail(1)) SWIG_fail;
10878 }
10879 {
10880 PyThreadState* __tstate = wxPyBeginAllowThreads();
10881 result = (bool)wxPyProcess::Exists(arg1);
10882
10883 wxPyEndAllowThreads(__tstate);
10884 if (PyErr_Occurred()) SWIG_fail;
10885 }
10886 {
10887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10888 }
10889 return resultobj;
10890 fail:
10891 return NULL;
10892 }
10893
10894
10895 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10896 PyObject *resultobj;
10897 wxString *arg1 = 0 ;
10898 int arg2 = (int) wxEXEC_ASYNC ;
10899 wxPyProcess *result;
10900 bool temp1 = false ;
10901 PyObject * obj0 = 0 ;
10902 PyObject * obj1 = 0 ;
10903 char *kwnames[] = {
10904 (char *) "cmd",(char *) "flags", NULL
10905 };
10906
10907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10908 {
10909 arg1 = wxString_in_helper(obj0);
10910 if (arg1 == NULL) SWIG_fail;
10911 temp1 = true;
10912 }
10913 if (obj1) {
10914 {
10915 arg2 = (int)(SWIG_As_int(obj1));
10916 if (SWIG_arg_fail(2)) SWIG_fail;
10917 }
10918 }
10919 {
10920 PyThreadState* __tstate = wxPyBeginAllowThreads();
10921 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10922
10923 wxPyEndAllowThreads(__tstate);
10924 if (PyErr_Occurred()) SWIG_fail;
10925 }
10926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10927 {
10928 if (temp1)
10929 delete arg1;
10930 }
10931 return resultobj;
10932 fail:
10933 {
10934 if (temp1)
10935 delete arg1;
10936 }
10937 return NULL;
10938 }
10939
10940
10941 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10942 PyObject *resultobj;
10943 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10944 int arg2 = (int) -1 ;
10945 wxPyProcess *result;
10946 PyObject * obj0 = 0 ;
10947 PyObject * obj1 = 0 ;
10948 char *kwnames[] = {
10949 (char *) "parent",(char *) "id", NULL
10950 };
10951
10952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10953 if (obj0) {
10954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10955 if (SWIG_arg_fail(1)) SWIG_fail;
10956 }
10957 if (obj1) {
10958 {
10959 arg2 = (int)(SWIG_As_int(obj1));
10960 if (SWIG_arg_fail(2)) SWIG_fail;
10961 }
10962 }
10963 {
10964 PyThreadState* __tstate = wxPyBeginAllowThreads();
10965 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10966
10967 wxPyEndAllowThreads(__tstate);
10968 if (PyErr_Occurred()) SWIG_fail;
10969 }
10970 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10971 return resultobj;
10972 fail:
10973 return NULL;
10974 }
10975
10976
10977 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10978 PyObject *resultobj;
10979 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10980 PyObject *arg2 = (PyObject *) 0 ;
10981 PyObject *arg3 = (PyObject *) 0 ;
10982 PyObject * obj0 = 0 ;
10983 PyObject * obj1 = 0 ;
10984 PyObject * obj2 = 0 ;
10985 char *kwnames[] = {
10986 (char *) "self",(char *) "self",(char *) "_class", NULL
10987 };
10988
10989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10991 if (SWIG_arg_fail(1)) SWIG_fail;
10992 arg2 = obj1;
10993 arg3 = obj2;
10994 {
10995 PyThreadState* __tstate = wxPyBeginAllowThreads();
10996 (arg1)->_setCallbackInfo(arg2,arg3);
10997
10998 wxPyEndAllowThreads(__tstate);
10999 if (PyErr_Occurred()) SWIG_fail;
11000 }
11001 Py_INCREF(Py_None); resultobj = Py_None;
11002 return resultobj;
11003 fail:
11004 return NULL;
11005 }
11006
11007
11008 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
11009 PyObject *resultobj;
11010 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11011 int arg2 ;
11012 int arg3 ;
11013 PyObject * obj0 = 0 ;
11014 PyObject * obj1 = 0 ;
11015 PyObject * obj2 = 0 ;
11016 char *kwnames[] = {
11017 (char *) "self",(char *) "pid",(char *) "status", NULL
11018 };
11019
11020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
11021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11022 if (SWIG_arg_fail(1)) SWIG_fail;
11023 {
11024 arg2 = (int)(SWIG_As_int(obj1));
11025 if (SWIG_arg_fail(2)) SWIG_fail;
11026 }
11027 {
11028 arg3 = (int)(SWIG_As_int(obj2));
11029 if (SWIG_arg_fail(3)) SWIG_fail;
11030 }
11031 {
11032 PyThreadState* __tstate = wxPyBeginAllowThreads();
11033 (arg1)->base_OnTerminate(arg2,arg3);
11034
11035 wxPyEndAllowThreads(__tstate);
11036 if (PyErr_Occurred()) SWIG_fail;
11037 }
11038 Py_INCREF(Py_None); resultobj = Py_None;
11039 return resultobj;
11040 fail:
11041 return NULL;
11042 }
11043
11044
11045 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11046 PyObject *resultobj;
11047 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11048 PyObject * obj0 = 0 ;
11049 char *kwnames[] = {
11050 (char *) "self", NULL
11051 };
11052
11053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11055 if (SWIG_arg_fail(1)) SWIG_fail;
11056 {
11057 PyThreadState* __tstate = wxPyBeginAllowThreads();
11058 (arg1)->Redirect();
11059
11060 wxPyEndAllowThreads(__tstate);
11061 if (PyErr_Occurred()) SWIG_fail;
11062 }
11063 Py_INCREF(Py_None); resultobj = Py_None;
11064 return resultobj;
11065 fail:
11066 return NULL;
11067 }
11068
11069
11070 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11071 PyObject *resultobj;
11072 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11073 bool result;
11074 PyObject * obj0 = 0 ;
11075 char *kwnames[] = {
11076 (char *) "self", NULL
11077 };
11078
11079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11081 if (SWIG_arg_fail(1)) SWIG_fail;
11082 {
11083 PyThreadState* __tstate = wxPyBeginAllowThreads();
11084 result = (bool)(arg1)->IsRedirected();
11085
11086 wxPyEndAllowThreads(__tstate);
11087 if (PyErr_Occurred()) SWIG_fail;
11088 }
11089 {
11090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11091 }
11092 return resultobj;
11093 fail:
11094 return NULL;
11095 }
11096
11097
11098 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11099 PyObject *resultobj;
11100 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11101 PyObject * obj0 = 0 ;
11102 char *kwnames[] = {
11103 (char *) "self", NULL
11104 };
11105
11106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11108 if (SWIG_arg_fail(1)) SWIG_fail;
11109 {
11110 PyThreadState* __tstate = wxPyBeginAllowThreads();
11111 (arg1)->Detach();
11112
11113 wxPyEndAllowThreads(__tstate);
11114 if (PyErr_Occurred()) SWIG_fail;
11115 }
11116 Py_INCREF(Py_None); resultobj = Py_None;
11117 return resultobj;
11118 fail:
11119 return NULL;
11120 }
11121
11122
11123 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11124 PyObject *resultobj;
11125 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11126 wxInputStream *result;
11127 PyObject * obj0 = 0 ;
11128 char *kwnames[] = {
11129 (char *) "self", NULL
11130 };
11131
11132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11134 if (SWIG_arg_fail(1)) SWIG_fail;
11135 {
11136 PyThreadState* __tstate = wxPyBeginAllowThreads();
11137 result = (wxInputStream *)(arg1)->GetInputStream();
11138
11139 wxPyEndAllowThreads(__tstate);
11140 if (PyErr_Occurred()) SWIG_fail;
11141 }
11142 {
11143 wxPyInputStream * _ptr = NULL;
11144
11145 if (result) {
11146 _ptr = new wxPyInputStream(result);
11147 }
11148 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11149 }
11150 return resultobj;
11151 fail:
11152 return NULL;
11153 }
11154
11155
11156 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11157 PyObject *resultobj;
11158 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11159 wxInputStream *result;
11160 PyObject * obj0 = 0 ;
11161 char *kwnames[] = {
11162 (char *) "self", NULL
11163 };
11164
11165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11167 if (SWIG_arg_fail(1)) SWIG_fail;
11168 {
11169 PyThreadState* __tstate = wxPyBeginAllowThreads();
11170 result = (wxInputStream *)(arg1)->GetErrorStream();
11171
11172 wxPyEndAllowThreads(__tstate);
11173 if (PyErr_Occurred()) SWIG_fail;
11174 }
11175 {
11176 wxPyInputStream * _ptr = NULL;
11177
11178 if (result) {
11179 _ptr = new wxPyInputStream(result);
11180 }
11181 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11182 }
11183 return resultobj;
11184 fail:
11185 return NULL;
11186 }
11187
11188
11189 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11190 PyObject *resultobj;
11191 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11192 wxOutputStream *result;
11193 PyObject * obj0 = 0 ;
11194 char *kwnames[] = {
11195 (char *) "self", NULL
11196 };
11197
11198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11200 if (SWIG_arg_fail(1)) SWIG_fail;
11201 {
11202 PyThreadState* __tstate = wxPyBeginAllowThreads();
11203 result = (wxOutputStream *)(arg1)->GetOutputStream();
11204
11205 wxPyEndAllowThreads(__tstate);
11206 if (PyErr_Occurred()) SWIG_fail;
11207 }
11208 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11209 return resultobj;
11210 fail:
11211 return NULL;
11212 }
11213
11214
11215 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11216 PyObject *resultobj;
11217 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11218 PyObject * obj0 = 0 ;
11219 char *kwnames[] = {
11220 (char *) "self", NULL
11221 };
11222
11223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11225 if (SWIG_arg_fail(1)) SWIG_fail;
11226 {
11227 PyThreadState* __tstate = wxPyBeginAllowThreads();
11228 (arg1)->CloseOutput();
11229
11230 wxPyEndAllowThreads(__tstate);
11231 if (PyErr_Occurred()) SWIG_fail;
11232 }
11233 Py_INCREF(Py_None); resultobj = Py_None;
11234 return resultobj;
11235 fail:
11236 return NULL;
11237 }
11238
11239
11240 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11241 PyObject *resultobj;
11242 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11243 bool result;
11244 PyObject * obj0 = 0 ;
11245 char *kwnames[] = {
11246 (char *) "self", NULL
11247 };
11248
11249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11251 if (SWIG_arg_fail(1)) SWIG_fail;
11252 {
11253 PyThreadState* __tstate = wxPyBeginAllowThreads();
11254 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11255
11256 wxPyEndAllowThreads(__tstate);
11257 if (PyErr_Occurred()) SWIG_fail;
11258 }
11259 {
11260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11261 }
11262 return resultobj;
11263 fail:
11264 return NULL;
11265 }
11266
11267
11268 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11269 PyObject *resultobj;
11270 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11271 bool result;
11272 PyObject * obj0 = 0 ;
11273 char *kwnames[] = {
11274 (char *) "self", NULL
11275 };
11276
11277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11279 if (SWIG_arg_fail(1)) SWIG_fail;
11280 {
11281 PyThreadState* __tstate = wxPyBeginAllowThreads();
11282 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11283
11284 wxPyEndAllowThreads(__tstate);
11285 if (PyErr_Occurred()) SWIG_fail;
11286 }
11287 {
11288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11289 }
11290 return resultobj;
11291 fail:
11292 return NULL;
11293 }
11294
11295
11296 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11297 PyObject *resultobj;
11298 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11299 bool result;
11300 PyObject * obj0 = 0 ;
11301 char *kwnames[] = {
11302 (char *) "self", NULL
11303 };
11304
11305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11307 if (SWIG_arg_fail(1)) SWIG_fail;
11308 {
11309 PyThreadState* __tstate = wxPyBeginAllowThreads();
11310 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11311
11312 wxPyEndAllowThreads(__tstate);
11313 if (PyErr_Occurred()) SWIG_fail;
11314 }
11315 {
11316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11317 }
11318 return resultobj;
11319 fail:
11320 return NULL;
11321 }
11322
11323
11324 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11325 PyObject *obj;
11326 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11327 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11328 Py_INCREF(obj);
11329 return Py_BuildValue((char *)"");
11330 }
11331 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11332 PyObject *resultobj;
11333 int arg1 = (int) 0 ;
11334 int arg2 = (int) 0 ;
11335 int arg3 = (int) 0 ;
11336 wxProcessEvent *result;
11337 PyObject * obj0 = 0 ;
11338 PyObject * obj1 = 0 ;
11339 PyObject * obj2 = 0 ;
11340 char *kwnames[] = {
11341 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11342 };
11343
11344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11345 if (obj0) {
11346 {
11347 arg1 = (int)(SWIG_As_int(obj0));
11348 if (SWIG_arg_fail(1)) SWIG_fail;
11349 }
11350 }
11351 if (obj1) {
11352 {
11353 arg2 = (int)(SWIG_As_int(obj1));
11354 if (SWIG_arg_fail(2)) SWIG_fail;
11355 }
11356 }
11357 if (obj2) {
11358 {
11359 arg3 = (int)(SWIG_As_int(obj2));
11360 if (SWIG_arg_fail(3)) SWIG_fail;
11361 }
11362 }
11363 {
11364 PyThreadState* __tstate = wxPyBeginAllowThreads();
11365 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11366
11367 wxPyEndAllowThreads(__tstate);
11368 if (PyErr_Occurred()) SWIG_fail;
11369 }
11370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11371 return resultobj;
11372 fail:
11373 return NULL;
11374 }
11375
11376
11377 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11378 PyObject *resultobj;
11379 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11380 int result;
11381 PyObject * obj0 = 0 ;
11382 char *kwnames[] = {
11383 (char *) "self", NULL
11384 };
11385
11386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11388 if (SWIG_arg_fail(1)) SWIG_fail;
11389 {
11390 PyThreadState* __tstate = wxPyBeginAllowThreads();
11391 result = (int)(arg1)->GetPid();
11392
11393 wxPyEndAllowThreads(__tstate);
11394 if (PyErr_Occurred()) SWIG_fail;
11395 }
11396 {
11397 resultobj = SWIG_From_int((int)(result));
11398 }
11399 return resultobj;
11400 fail:
11401 return NULL;
11402 }
11403
11404
11405 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11406 PyObject *resultobj;
11407 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11408 int result;
11409 PyObject * obj0 = 0 ;
11410 char *kwnames[] = {
11411 (char *) "self", NULL
11412 };
11413
11414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11416 if (SWIG_arg_fail(1)) SWIG_fail;
11417 {
11418 PyThreadState* __tstate = wxPyBeginAllowThreads();
11419 result = (int)(arg1)->GetExitCode();
11420
11421 wxPyEndAllowThreads(__tstate);
11422 if (PyErr_Occurred()) SWIG_fail;
11423 }
11424 {
11425 resultobj = SWIG_From_int((int)(result));
11426 }
11427 return resultobj;
11428 fail:
11429 return NULL;
11430 }
11431
11432
11433 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11434 PyObject *resultobj;
11435 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11436 int arg2 ;
11437 PyObject * obj0 = 0 ;
11438 PyObject * obj1 = 0 ;
11439 char *kwnames[] = {
11440 (char *) "self",(char *) "m_pid", NULL
11441 };
11442
11443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11445 if (SWIG_arg_fail(1)) SWIG_fail;
11446 {
11447 arg2 = (int)(SWIG_As_int(obj1));
11448 if (SWIG_arg_fail(2)) SWIG_fail;
11449 }
11450 if (arg1) (arg1)->m_pid = arg2;
11451
11452 Py_INCREF(Py_None); resultobj = Py_None;
11453 return resultobj;
11454 fail:
11455 return NULL;
11456 }
11457
11458
11459 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11460 PyObject *resultobj;
11461 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11462 int result;
11463 PyObject * obj0 = 0 ;
11464 char *kwnames[] = {
11465 (char *) "self", NULL
11466 };
11467
11468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11470 if (SWIG_arg_fail(1)) SWIG_fail;
11471 result = (int) ((arg1)->m_pid);
11472
11473 {
11474 resultobj = SWIG_From_int((int)(result));
11475 }
11476 return resultobj;
11477 fail:
11478 return NULL;
11479 }
11480
11481
11482 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11483 PyObject *resultobj;
11484 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11485 int arg2 ;
11486 PyObject * obj0 = 0 ;
11487 PyObject * obj1 = 0 ;
11488 char *kwnames[] = {
11489 (char *) "self",(char *) "m_exitcode", NULL
11490 };
11491
11492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11494 if (SWIG_arg_fail(1)) SWIG_fail;
11495 {
11496 arg2 = (int)(SWIG_As_int(obj1));
11497 if (SWIG_arg_fail(2)) SWIG_fail;
11498 }
11499 if (arg1) (arg1)->m_exitcode = arg2;
11500
11501 Py_INCREF(Py_None); resultobj = Py_None;
11502 return resultobj;
11503 fail:
11504 return NULL;
11505 }
11506
11507
11508 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11509 PyObject *resultobj;
11510 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11511 int result;
11512 PyObject * obj0 = 0 ;
11513 char *kwnames[] = {
11514 (char *) "self", NULL
11515 };
11516
11517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11519 if (SWIG_arg_fail(1)) SWIG_fail;
11520 result = (int) ((arg1)->m_exitcode);
11521
11522 {
11523 resultobj = SWIG_From_int((int)(result));
11524 }
11525 return resultobj;
11526 fail:
11527 return NULL;
11528 }
11529
11530
11531 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11532 PyObject *obj;
11533 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11534 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11535 Py_INCREF(obj);
11536 return Py_BuildValue((char *)"");
11537 }
11538 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11539 PyObject *resultobj;
11540 wxString *arg1 = 0 ;
11541 int arg2 = (int) wxEXEC_ASYNC ;
11542 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11543 long result;
11544 bool temp1 = false ;
11545 PyObject * obj0 = 0 ;
11546 PyObject * obj1 = 0 ;
11547 PyObject * obj2 = 0 ;
11548 char *kwnames[] = {
11549 (char *) "command",(char *) "flags",(char *) "process", NULL
11550 };
11551
11552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11553 {
11554 arg1 = wxString_in_helper(obj0);
11555 if (arg1 == NULL) SWIG_fail;
11556 temp1 = true;
11557 }
11558 if (obj1) {
11559 {
11560 arg2 = (int)(SWIG_As_int(obj1));
11561 if (SWIG_arg_fail(2)) SWIG_fail;
11562 }
11563 }
11564 if (obj2) {
11565 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11566 if (SWIG_arg_fail(3)) SWIG_fail;
11567 }
11568 {
11569 if (!wxPyCheckForApp()) SWIG_fail;
11570 PyThreadState* __tstate = wxPyBeginAllowThreads();
11571 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11572
11573 wxPyEndAllowThreads(__tstate);
11574 if (PyErr_Occurred()) SWIG_fail;
11575 }
11576 {
11577 resultobj = SWIG_From_long((long)(result));
11578 }
11579 {
11580 if (temp1)
11581 delete arg1;
11582 }
11583 return resultobj;
11584 fail:
11585 {
11586 if (temp1)
11587 delete arg1;
11588 }
11589 return NULL;
11590 }
11591
11592
11593 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11594 PyObject *resultobj;
11595 long arg1 ;
11596 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11597 wxKillError *arg3 = (wxKillError *) 0 ;
11598 int arg4 = (int) wxKILL_NOCHILDREN ;
11599 int result;
11600 wxKillError temp3 ;
11601 PyObject * obj0 = 0 ;
11602 PyObject * obj1 = 0 ;
11603 PyObject * obj2 = 0 ;
11604 char *kwnames[] = {
11605 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11606 };
11607
11608 {
11609 arg3 = &temp3;
11610 }
11611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11612 {
11613 arg1 = (long)(SWIG_As_long(obj0));
11614 if (SWIG_arg_fail(1)) SWIG_fail;
11615 }
11616 if (obj1) {
11617 {
11618 arg2 = (wxSignal)(SWIG_As_int(obj1));
11619 if (SWIG_arg_fail(2)) SWIG_fail;
11620 }
11621 }
11622 if (obj2) {
11623 {
11624 arg4 = (int)(SWIG_As_int(obj2));
11625 if (SWIG_arg_fail(4)) SWIG_fail;
11626 }
11627 }
11628 {
11629 PyThreadState* __tstate = wxPyBeginAllowThreads();
11630 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11631
11632 wxPyEndAllowThreads(__tstate);
11633 if (PyErr_Occurred()) SWIG_fail;
11634 }
11635 {
11636 resultobj = SWIG_From_int((int)(result));
11637 }
11638 {
11639 PyObject* o;
11640 o = PyInt_FromLong((long) (*arg3));
11641 resultobj = t_output_helper(resultobj, o);
11642 }
11643 return resultobj;
11644 fail:
11645 return NULL;
11646 }
11647
11648
11649 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11650 PyObject *resultobj;
11651 int arg1 = (int) wxJOYSTICK1 ;
11652 wxJoystick *result;
11653 PyObject * obj0 = 0 ;
11654 char *kwnames[] = {
11655 (char *) "joystick", NULL
11656 };
11657
11658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11659 if (obj0) {
11660 {
11661 arg1 = (int)(SWIG_As_int(obj0));
11662 if (SWIG_arg_fail(1)) SWIG_fail;
11663 }
11664 }
11665 {
11666 if (!wxPyCheckForApp()) SWIG_fail;
11667 PyThreadState* __tstate = wxPyBeginAllowThreads();
11668 result = (wxJoystick *)new wxJoystick(arg1);
11669
11670 wxPyEndAllowThreads(__tstate);
11671 if (PyErr_Occurred()) SWIG_fail;
11672 }
11673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11674 return resultobj;
11675 fail:
11676 return NULL;
11677 }
11678
11679
11680 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11681 PyObject *resultobj;
11682 wxJoystick *arg1 = (wxJoystick *) 0 ;
11683 PyObject * obj0 = 0 ;
11684 char *kwnames[] = {
11685 (char *) "self", NULL
11686 };
11687
11688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11690 if (SWIG_arg_fail(1)) SWIG_fail;
11691 {
11692 PyThreadState* __tstate = wxPyBeginAllowThreads();
11693 delete arg1;
11694
11695 wxPyEndAllowThreads(__tstate);
11696 if (PyErr_Occurred()) SWIG_fail;
11697 }
11698 Py_INCREF(Py_None); resultobj = Py_None;
11699 return resultobj;
11700 fail:
11701 return NULL;
11702 }
11703
11704
11705 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11706 PyObject *resultobj;
11707 wxJoystick *arg1 = (wxJoystick *) 0 ;
11708 wxPoint result;
11709 PyObject * obj0 = 0 ;
11710 char *kwnames[] = {
11711 (char *) "self", NULL
11712 };
11713
11714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11716 if (SWIG_arg_fail(1)) SWIG_fail;
11717 {
11718 PyThreadState* __tstate = wxPyBeginAllowThreads();
11719 result = (arg1)->GetPosition();
11720
11721 wxPyEndAllowThreads(__tstate);
11722 if (PyErr_Occurred()) SWIG_fail;
11723 }
11724 {
11725 wxPoint * resultptr;
11726 resultptr = new wxPoint((wxPoint &)(result));
11727 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11728 }
11729 return resultobj;
11730 fail:
11731 return NULL;
11732 }
11733
11734
11735 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11736 PyObject *resultobj;
11737 wxJoystick *arg1 = (wxJoystick *) 0 ;
11738 int result;
11739 PyObject * obj0 = 0 ;
11740 char *kwnames[] = {
11741 (char *) "self", NULL
11742 };
11743
11744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11746 if (SWIG_arg_fail(1)) SWIG_fail;
11747 {
11748 PyThreadState* __tstate = wxPyBeginAllowThreads();
11749 result = (int)(arg1)->GetZPosition();
11750
11751 wxPyEndAllowThreads(__tstate);
11752 if (PyErr_Occurred()) SWIG_fail;
11753 }
11754 {
11755 resultobj = SWIG_From_int((int)(result));
11756 }
11757 return resultobj;
11758 fail:
11759 return NULL;
11760 }
11761
11762
11763 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11764 PyObject *resultobj;
11765 wxJoystick *arg1 = (wxJoystick *) 0 ;
11766 int result;
11767 PyObject * obj0 = 0 ;
11768 char *kwnames[] = {
11769 (char *) "self", NULL
11770 };
11771
11772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11774 if (SWIG_arg_fail(1)) SWIG_fail;
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 result = (int)(arg1)->GetButtonState();
11778
11779 wxPyEndAllowThreads(__tstate);
11780 if (PyErr_Occurred()) SWIG_fail;
11781 }
11782 {
11783 resultobj = SWIG_From_int((int)(result));
11784 }
11785 return resultobj;
11786 fail:
11787 return NULL;
11788 }
11789
11790
11791 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11792 PyObject *resultobj;
11793 wxJoystick *arg1 = (wxJoystick *) 0 ;
11794 int result;
11795 PyObject * obj0 = 0 ;
11796 char *kwnames[] = {
11797 (char *) "self", NULL
11798 };
11799
11800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11802 if (SWIG_arg_fail(1)) SWIG_fail;
11803 {
11804 PyThreadState* __tstate = wxPyBeginAllowThreads();
11805 result = (int)(arg1)->GetPOVPosition();
11806
11807 wxPyEndAllowThreads(__tstate);
11808 if (PyErr_Occurred()) SWIG_fail;
11809 }
11810 {
11811 resultobj = SWIG_From_int((int)(result));
11812 }
11813 return resultobj;
11814 fail:
11815 return NULL;
11816 }
11817
11818
11819 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11820 PyObject *resultobj;
11821 wxJoystick *arg1 = (wxJoystick *) 0 ;
11822 int result;
11823 PyObject * obj0 = 0 ;
11824 char *kwnames[] = {
11825 (char *) "self", NULL
11826 };
11827
11828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11830 if (SWIG_arg_fail(1)) SWIG_fail;
11831 {
11832 PyThreadState* __tstate = wxPyBeginAllowThreads();
11833 result = (int)(arg1)->GetPOVCTSPosition();
11834
11835 wxPyEndAllowThreads(__tstate);
11836 if (PyErr_Occurred()) SWIG_fail;
11837 }
11838 {
11839 resultobj = SWIG_From_int((int)(result));
11840 }
11841 return resultobj;
11842 fail:
11843 return NULL;
11844 }
11845
11846
11847 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11848 PyObject *resultobj;
11849 wxJoystick *arg1 = (wxJoystick *) 0 ;
11850 int result;
11851 PyObject * obj0 = 0 ;
11852 char *kwnames[] = {
11853 (char *) "self", NULL
11854 };
11855
11856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11858 if (SWIG_arg_fail(1)) SWIG_fail;
11859 {
11860 PyThreadState* __tstate = wxPyBeginAllowThreads();
11861 result = (int)(arg1)->GetRudderPosition();
11862
11863 wxPyEndAllowThreads(__tstate);
11864 if (PyErr_Occurred()) SWIG_fail;
11865 }
11866 {
11867 resultobj = SWIG_From_int((int)(result));
11868 }
11869 return resultobj;
11870 fail:
11871 return NULL;
11872 }
11873
11874
11875 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11876 PyObject *resultobj;
11877 wxJoystick *arg1 = (wxJoystick *) 0 ;
11878 int result;
11879 PyObject * obj0 = 0 ;
11880 char *kwnames[] = {
11881 (char *) "self", NULL
11882 };
11883
11884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11886 if (SWIG_arg_fail(1)) SWIG_fail;
11887 {
11888 PyThreadState* __tstate = wxPyBeginAllowThreads();
11889 result = (int)(arg1)->GetUPosition();
11890
11891 wxPyEndAllowThreads(__tstate);
11892 if (PyErr_Occurred()) SWIG_fail;
11893 }
11894 {
11895 resultobj = SWIG_From_int((int)(result));
11896 }
11897 return resultobj;
11898 fail:
11899 return NULL;
11900 }
11901
11902
11903 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11904 PyObject *resultobj;
11905 wxJoystick *arg1 = (wxJoystick *) 0 ;
11906 int result;
11907 PyObject * obj0 = 0 ;
11908 char *kwnames[] = {
11909 (char *) "self", NULL
11910 };
11911
11912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11914 if (SWIG_arg_fail(1)) SWIG_fail;
11915 {
11916 PyThreadState* __tstate = wxPyBeginAllowThreads();
11917 result = (int)(arg1)->GetVPosition();
11918
11919 wxPyEndAllowThreads(__tstate);
11920 if (PyErr_Occurred()) SWIG_fail;
11921 }
11922 {
11923 resultobj = SWIG_From_int((int)(result));
11924 }
11925 return resultobj;
11926 fail:
11927 return NULL;
11928 }
11929
11930
11931 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11932 PyObject *resultobj;
11933 wxJoystick *arg1 = (wxJoystick *) 0 ;
11934 int result;
11935 PyObject * obj0 = 0 ;
11936 char *kwnames[] = {
11937 (char *) "self", NULL
11938 };
11939
11940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11942 if (SWIG_arg_fail(1)) SWIG_fail;
11943 {
11944 PyThreadState* __tstate = wxPyBeginAllowThreads();
11945 result = (int)(arg1)->GetMovementThreshold();
11946
11947 wxPyEndAllowThreads(__tstate);
11948 if (PyErr_Occurred()) SWIG_fail;
11949 }
11950 {
11951 resultobj = SWIG_From_int((int)(result));
11952 }
11953 return resultobj;
11954 fail:
11955 return NULL;
11956 }
11957
11958
11959 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11960 PyObject *resultobj;
11961 wxJoystick *arg1 = (wxJoystick *) 0 ;
11962 int arg2 ;
11963 PyObject * obj0 = 0 ;
11964 PyObject * obj1 = 0 ;
11965 char *kwnames[] = {
11966 (char *) "self",(char *) "threshold", NULL
11967 };
11968
11969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11971 if (SWIG_arg_fail(1)) SWIG_fail;
11972 {
11973 arg2 = (int)(SWIG_As_int(obj1));
11974 if (SWIG_arg_fail(2)) SWIG_fail;
11975 }
11976 {
11977 PyThreadState* __tstate = wxPyBeginAllowThreads();
11978 (arg1)->SetMovementThreshold(arg2);
11979
11980 wxPyEndAllowThreads(__tstate);
11981 if (PyErr_Occurred()) SWIG_fail;
11982 }
11983 Py_INCREF(Py_None); resultobj = Py_None;
11984 return resultobj;
11985 fail:
11986 return NULL;
11987 }
11988
11989
11990 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11991 PyObject *resultobj;
11992 wxJoystick *arg1 = (wxJoystick *) 0 ;
11993 bool result;
11994 PyObject * obj0 = 0 ;
11995 char *kwnames[] = {
11996 (char *) "self", NULL
11997 };
11998
11999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
12000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12001 if (SWIG_arg_fail(1)) SWIG_fail;
12002 {
12003 PyThreadState* __tstate = wxPyBeginAllowThreads();
12004 result = (bool)(arg1)->IsOk();
12005
12006 wxPyEndAllowThreads(__tstate);
12007 if (PyErr_Occurred()) SWIG_fail;
12008 }
12009 {
12010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12011 }
12012 return resultobj;
12013 fail:
12014 return NULL;
12015 }
12016
12017
12018 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
12019 PyObject *resultobj;
12020 wxJoystick *arg1 = (wxJoystick *) 0 ;
12021 int result;
12022 PyObject * obj0 = 0 ;
12023 char *kwnames[] = {
12024 (char *) "self", NULL
12025 };
12026
12027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
12028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12029 if (SWIG_arg_fail(1)) SWIG_fail;
12030 {
12031 PyThreadState* __tstate = wxPyBeginAllowThreads();
12032 result = (int)(arg1)->GetNumberJoysticks();
12033
12034 wxPyEndAllowThreads(__tstate);
12035 if (PyErr_Occurred()) SWIG_fail;
12036 }
12037 {
12038 resultobj = SWIG_From_int((int)(result));
12039 }
12040 return resultobj;
12041 fail:
12042 return NULL;
12043 }
12044
12045
12046 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12047 PyObject *resultobj;
12048 wxJoystick *arg1 = (wxJoystick *) 0 ;
12049 int result;
12050 PyObject * obj0 = 0 ;
12051 char *kwnames[] = {
12052 (char *) "self", NULL
12053 };
12054
12055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12057 if (SWIG_arg_fail(1)) SWIG_fail;
12058 {
12059 PyThreadState* __tstate = wxPyBeginAllowThreads();
12060 result = (int)(arg1)->GetManufacturerId();
12061
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 {
12066 resultobj = SWIG_From_int((int)(result));
12067 }
12068 return resultobj;
12069 fail:
12070 return NULL;
12071 }
12072
12073
12074 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12075 PyObject *resultobj;
12076 wxJoystick *arg1 = (wxJoystick *) 0 ;
12077 int result;
12078 PyObject * obj0 = 0 ;
12079 char *kwnames[] = {
12080 (char *) "self", NULL
12081 };
12082
12083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12085 if (SWIG_arg_fail(1)) SWIG_fail;
12086 {
12087 PyThreadState* __tstate = wxPyBeginAllowThreads();
12088 result = (int)(arg1)->GetProductId();
12089
12090 wxPyEndAllowThreads(__tstate);
12091 if (PyErr_Occurred()) SWIG_fail;
12092 }
12093 {
12094 resultobj = SWIG_From_int((int)(result));
12095 }
12096 return resultobj;
12097 fail:
12098 return NULL;
12099 }
12100
12101
12102 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12103 PyObject *resultobj;
12104 wxJoystick *arg1 = (wxJoystick *) 0 ;
12105 wxString result;
12106 PyObject * obj0 = 0 ;
12107 char *kwnames[] = {
12108 (char *) "self", NULL
12109 };
12110
12111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12113 if (SWIG_arg_fail(1)) SWIG_fail;
12114 {
12115 PyThreadState* __tstate = wxPyBeginAllowThreads();
12116 result = (arg1)->GetProductName();
12117
12118 wxPyEndAllowThreads(__tstate);
12119 if (PyErr_Occurred()) SWIG_fail;
12120 }
12121 {
12122 #if wxUSE_UNICODE
12123 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12124 #else
12125 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12126 #endif
12127 }
12128 return resultobj;
12129 fail:
12130 return NULL;
12131 }
12132
12133
12134 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12135 PyObject *resultobj;
12136 wxJoystick *arg1 = (wxJoystick *) 0 ;
12137 int result;
12138 PyObject * obj0 = 0 ;
12139 char *kwnames[] = {
12140 (char *) "self", NULL
12141 };
12142
12143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12145 if (SWIG_arg_fail(1)) SWIG_fail;
12146 {
12147 PyThreadState* __tstate = wxPyBeginAllowThreads();
12148 result = (int)(arg1)->GetXMin();
12149
12150 wxPyEndAllowThreads(__tstate);
12151 if (PyErr_Occurred()) SWIG_fail;
12152 }
12153 {
12154 resultobj = SWIG_From_int((int)(result));
12155 }
12156 return resultobj;
12157 fail:
12158 return NULL;
12159 }
12160
12161
12162 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12163 PyObject *resultobj;
12164 wxJoystick *arg1 = (wxJoystick *) 0 ;
12165 int result;
12166 PyObject * obj0 = 0 ;
12167 char *kwnames[] = {
12168 (char *) "self", NULL
12169 };
12170
12171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12173 if (SWIG_arg_fail(1)) SWIG_fail;
12174 {
12175 PyThreadState* __tstate = wxPyBeginAllowThreads();
12176 result = (int)(arg1)->GetYMin();
12177
12178 wxPyEndAllowThreads(__tstate);
12179 if (PyErr_Occurred()) SWIG_fail;
12180 }
12181 {
12182 resultobj = SWIG_From_int((int)(result));
12183 }
12184 return resultobj;
12185 fail:
12186 return NULL;
12187 }
12188
12189
12190 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12191 PyObject *resultobj;
12192 wxJoystick *arg1 = (wxJoystick *) 0 ;
12193 int result;
12194 PyObject * obj0 = 0 ;
12195 char *kwnames[] = {
12196 (char *) "self", NULL
12197 };
12198
12199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12201 if (SWIG_arg_fail(1)) SWIG_fail;
12202 {
12203 PyThreadState* __tstate = wxPyBeginAllowThreads();
12204 result = (int)(arg1)->GetZMin();
12205
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 {
12210 resultobj = SWIG_From_int((int)(result));
12211 }
12212 return resultobj;
12213 fail:
12214 return NULL;
12215 }
12216
12217
12218 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12219 PyObject *resultobj;
12220 wxJoystick *arg1 = (wxJoystick *) 0 ;
12221 int result;
12222 PyObject * obj0 = 0 ;
12223 char *kwnames[] = {
12224 (char *) "self", NULL
12225 };
12226
12227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12229 if (SWIG_arg_fail(1)) SWIG_fail;
12230 {
12231 PyThreadState* __tstate = wxPyBeginAllowThreads();
12232 result = (int)(arg1)->GetXMax();
12233
12234 wxPyEndAllowThreads(__tstate);
12235 if (PyErr_Occurred()) SWIG_fail;
12236 }
12237 {
12238 resultobj = SWIG_From_int((int)(result));
12239 }
12240 return resultobj;
12241 fail:
12242 return NULL;
12243 }
12244
12245
12246 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12247 PyObject *resultobj;
12248 wxJoystick *arg1 = (wxJoystick *) 0 ;
12249 int result;
12250 PyObject * obj0 = 0 ;
12251 char *kwnames[] = {
12252 (char *) "self", NULL
12253 };
12254
12255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12257 if (SWIG_arg_fail(1)) SWIG_fail;
12258 {
12259 PyThreadState* __tstate = wxPyBeginAllowThreads();
12260 result = (int)(arg1)->GetYMax();
12261
12262 wxPyEndAllowThreads(__tstate);
12263 if (PyErr_Occurred()) SWIG_fail;
12264 }
12265 {
12266 resultobj = SWIG_From_int((int)(result));
12267 }
12268 return resultobj;
12269 fail:
12270 return NULL;
12271 }
12272
12273
12274 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12275 PyObject *resultobj;
12276 wxJoystick *arg1 = (wxJoystick *) 0 ;
12277 int result;
12278 PyObject * obj0 = 0 ;
12279 char *kwnames[] = {
12280 (char *) "self", NULL
12281 };
12282
12283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12285 if (SWIG_arg_fail(1)) SWIG_fail;
12286 {
12287 PyThreadState* __tstate = wxPyBeginAllowThreads();
12288 result = (int)(arg1)->GetZMax();
12289
12290 wxPyEndAllowThreads(__tstate);
12291 if (PyErr_Occurred()) SWIG_fail;
12292 }
12293 {
12294 resultobj = SWIG_From_int((int)(result));
12295 }
12296 return resultobj;
12297 fail:
12298 return NULL;
12299 }
12300
12301
12302 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12303 PyObject *resultobj;
12304 wxJoystick *arg1 = (wxJoystick *) 0 ;
12305 int result;
12306 PyObject * obj0 = 0 ;
12307 char *kwnames[] = {
12308 (char *) "self", NULL
12309 };
12310
12311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12313 if (SWIG_arg_fail(1)) SWIG_fail;
12314 {
12315 PyThreadState* __tstate = wxPyBeginAllowThreads();
12316 result = (int)(arg1)->GetNumberButtons();
12317
12318 wxPyEndAllowThreads(__tstate);
12319 if (PyErr_Occurred()) SWIG_fail;
12320 }
12321 {
12322 resultobj = SWIG_From_int((int)(result));
12323 }
12324 return resultobj;
12325 fail:
12326 return NULL;
12327 }
12328
12329
12330 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12331 PyObject *resultobj;
12332 wxJoystick *arg1 = (wxJoystick *) 0 ;
12333 int result;
12334 PyObject * obj0 = 0 ;
12335 char *kwnames[] = {
12336 (char *) "self", NULL
12337 };
12338
12339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12341 if (SWIG_arg_fail(1)) SWIG_fail;
12342 {
12343 PyThreadState* __tstate = wxPyBeginAllowThreads();
12344 result = (int)(arg1)->GetNumberAxes();
12345
12346 wxPyEndAllowThreads(__tstate);
12347 if (PyErr_Occurred()) SWIG_fail;
12348 }
12349 {
12350 resultobj = SWIG_From_int((int)(result));
12351 }
12352 return resultobj;
12353 fail:
12354 return NULL;
12355 }
12356
12357
12358 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12359 PyObject *resultobj;
12360 wxJoystick *arg1 = (wxJoystick *) 0 ;
12361 int result;
12362 PyObject * obj0 = 0 ;
12363 char *kwnames[] = {
12364 (char *) "self", NULL
12365 };
12366
12367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12369 if (SWIG_arg_fail(1)) SWIG_fail;
12370 {
12371 PyThreadState* __tstate = wxPyBeginAllowThreads();
12372 result = (int)(arg1)->GetMaxButtons();
12373
12374 wxPyEndAllowThreads(__tstate);
12375 if (PyErr_Occurred()) SWIG_fail;
12376 }
12377 {
12378 resultobj = SWIG_From_int((int)(result));
12379 }
12380 return resultobj;
12381 fail:
12382 return NULL;
12383 }
12384
12385
12386 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12387 PyObject *resultobj;
12388 wxJoystick *arg1 = (wxJoystick *) 0 ;
12389 int result;
12390 PyObject * obj0 = 0 ;
12391 char *kwnames[] = {
12392 (char *) "self", NULL
12393 };
12394
12395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12397 if (SWIG_arg_fail(1)) SWIG_fail;
12398 {
12399 PyThreadState* __tstate = wxPyBeginAllowThreads();
12400 result = (int)(arg1)->GetMaxAxes();
12401
12402 wxPyEndAllowThreads(__tstate);
12403 if (PyErr_Occurred()) SWIG_fail;
12404 }
12405 {
12406 resultobj = SWIG_From_int((int)(result));
12407 }
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj;
12416 wxJoystick *arg1 = (wxJoystick *) 0 ;
12417 int result;
12418 PyObject * obj0 = 0 ;
12419 char *kwnames[] = {
12420 (char *) "self", NULL
12421 };
12422
12423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12425 if (SWIG_arg_fail(1)) SWIG_fail;
12426 {
12427 PyThreadState* __tstate = wxPyBeginAllowThreads();
12428 result = (int)(arg1)->GetPollingMin();
12429
12430 wxPyEndAllowThreads(__tstate);
12431 if (PyErr_Occurred()) SWIG_fail;
12432 }
12433 {
12434 resultobj = SWIG_From_int((int)(result));
12435 }
12436 return resultobj;
12437 fail:
12438 return NULL;
12439 }
12440
12441
12442 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12443 PyObject *resultobj;
12444 wxJoystick *arg1 = (wxJoystick *) 0 ;
12445 int result;
12446 PyObject * obj0 = 0 ;
12447 char *kwnames[] = {
12448 (char *) "self", NULL
12449 };
12450
12451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12453 if (SWIG_arg_fail(1)) SWIG_fail;
12454 {
12455 PyThreadState* __tstate = wxPyBeginAllowThreads();
12456 result = (int)(arg1)->GetPollingMax();
12457
12458 wxPyEndAllowThreads(__tstate);
12459 if (PyErr_Occurred()) SWIG_fail;
12460 }
12461 {
12462 resultobj = SWIG_From_int((int)(result));
12463 }
12464 return resultobj;
12465 fail:
12466 return NULL;
12467 }
12468
12469
12470 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12471 PyObject *resultobj;
12472 wxJoystick *arg1 = (wxJoystick *) 0 ;
12473 int result;
12474 PyObject * obj0 = 0 ;
12475 char *kwnames[] = {
12476 (char *) "self", NULL
12477 };
12478
12479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12481 if (SWIG_arg_fail(1)) SWIG_fail;
12482 {
12483 PyThreadState* __tstate = wxPyBeginAllowThreads();
12484 result = (int)(arg1)->GetRudderMin();
12485
12486 wxPyEndAllowThreads(__tstate);
12487 if (PyErr_Occurred()) SWIG_fail;
12488 }
12489 {
12490 resultobj = SWIG_From_int((int)(result));
12491 }
12492 return resultobj;
12493 fail:
12494 return NULL;
12495 }
12496
12497
12498 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12499 PyObject *resultobj;
12500 wxJoystick *arg1 = (wxJoystick *) 0 ;
12501 int result;
12502 PyObject * obj0 = 0 ;
12503 char *kwnames[] = {
12504 (char *) "self", NULL
12505 };
12506
12507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12509 if (SWIG_arg_fail(1)) SWIG_fail;
12510 {
12511 PyThreadState* __tstate = wxPyBeginAllowThreads();
12512 result = (int)(arg1)->GetRudderMax();
12513
12514 wxPyEndAllowThreads(__tstate);
12515 if (PyErr_Occurred()) SWIG_fail;
12516 }
12517 {
12518 resultobj = SWIG_From_int((int)(result));
12519 }
12520 return resultobj;
12521 fail:
12522 return NULL;
12523 }
12524
12525
12526 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12527 PyObject *resultobj;
12528 wxJoystick *arg1 = (wxJoystick *) 0 ;
12529 int result;
12530 PyObject * obj0 = 0 ;
12531 char *kwnames[] = {
12532 (char *) "self", NULL
12533 };
12534
12535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12537 if (SWIG_arg_fail(1)) SWIG_fail;
12538 {
12539 PyThreadState* __tstate = wxPyBeginAllowThreads();
12540 result = (int)(arg1)->GetUMin();
12541
12542 wxPyEndAllowThreads(__tstate);
12543 if (PyErr_Occurred()) SWIG_fail;
12544 }
12545 {
12546 resultobj = SWIG_From_int((int)(result));
12547 }
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12555 PyObject *resultobj;
12556 wxJoystick *arg1 = (wxJoystick *) 0 ;
12557 int result;
12558 PyObject * obj0 = 0 ;
12559 char *kwnames[] = {
12560 (char *) "self", NULL
12561 };
12562
12563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12565 if (SWIG_arg_fail(1)) SWIG_fail;
12566 {
12567 PyThreadState* __tstate = wxPyBeginAllowThreads();
12568 result = (int)(arg1)->GetUMax();
12569
12570 wxPyEndAllowThreads(__tstate);
12571 if (PyErr_Occurred()) SWIG_fail;
12572 }
12573 {
12574 resultobj = SWIG_From_int((int)(result));
12575 }
12576 return resultobj;
12577 fail:
12578 return NULL;
12579 }
12580
12581
12582 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12583 PyObject *resultobj;
12584 wxJoystick *arg1 = (wxJoystick *) 0 ;
12585 int result;
12586 PyObject * obj0 = 0 ;
12587 char *kwnames[] = {
12588 (char *) "self", NULL
12589 };
12590
12591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12593 if (SWIG_arg_fail(1)) SWIG_fail;
12594 {
12595 PyThreadState* __tstate = wxPyBeginAllowThreads();
12596 result = (int)(arg1)->GetVMin();
12597
12598 wxPyEndAllowThreads(__tstate);
12599 if (PyErr_Occurred()) SWIG_fail;
12600 }
12601 {
12602 resultobj = SWIG_From_int((int)(result));
12603 }
12604 return resultobj;
12605 fail:
12606 return NULL;
12607 }
12608
12609
12610 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12611 PyObject *resultobj;
12612 wxJoystick *arg1 = (wxJoystick *) 0 ;
12613 int result;
12614 PyObject * obj0 = 0 ;
12615 char *kwnames[] = {
12616 (char *) "self", NULL
12617 };
12618
12619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12621 if (SWIG_arg_fail(1)) SWIG_fail;
12622 {
12623 PyThreadState* __tstate = wxPyBeginAllowThreads();
12624 result = (int)(arg1)->GetVMax();
12625
12626 wxPyEndAllowThreads(__tstate);
12627 if (PyErr_Occurred()) SWIG_fail;
12628 }
12629 {
12630 resultobj = SWIG_From_int((int)(result));
12631 }
12632 return resultobj;
12633 fail:
12634 return NULL;
12635 }
12636
12637
12638 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12639 PyObject *resultobj;
12640 wxJoystick *arg1 = (wxJoystick *) 0 ;
12641 bool result;
12642 PyObject * obj0 = 0 ;
12643 char *kwnames[] = {
12644 (char *) "self", NULL
12645 };
12646
12647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12649 if (SWIG_arg_fail(1)) SWIG_fail;
12650 {
12651 PyThreadState* __tstate = wxPyBeginAllowThreads();
12652 result = (bool)(arg1)->HasRudder();
12653
12654 wxPyEndAllowThreads(__tstate);
12655 if (PyErr_Occurred()) SWIG_fail;
12656 }
12657 {
12658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12659 }
12660 return resultobj;
12661 fail:
12662 return NULL;
12663 }
12664
12665
12666 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12667 PyObject *resultobj;
12668 wxJoystick *arg1 = (wxJoystick *) 0 ;
12669 bool result;
12670 PyObject * obj0 = 0 ;
12671 char *kwnames[] = {
12672 (char *) "self", NULL
12673 };
12674
12675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12677 if (SWIG_arg_fail(1)) SWIG_fail;
12678 {
12679 PyThreadState* __tstate = wxPyBeginAllowThreads();
12680 result = (bool)(arg1)->HasZ();
12681
12682 wxPyEndAllowThreads(__tstate);
12683 if (PyErr_Occurred()) SWIG_fail;
12684 }
12685 {
12686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12687 }
12688 return resultobj;
12689 fail:
12690 return NULL;
12691 }
12692
12693
12694 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12695 PyObject *resultobj;
12696 wxJoystick *arg1 = (wxJoystick *) 0 ;
12697 bool result;
12698 PyObject * obj0 = 0 ;
12699 char *kwnames[] = {
12700 (char *) "self", NULL
12701 };
12702
12703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12705 if (SWIG_arg_fail(1)) SWIG_fail;
12706 {
12707 PyThreadState* __tstate = wxPyBeginAllowThreads();
12708 result = (bool)(arg1)->HasU();
12709
12710 wxPyEndAllowThreads(__tstate);
12711 if (PyErr_Occurred()) SWIG_fail;
12712 }
12713 {
12714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12715 }
12716 return resultobj;
12717 fail:
12718 return NULL;
12719 }
12720
12721
12722 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12723 PyObject *resultobj;
12724 wxJoystick *arg1 = (wxJoystick *) 0 ;
12725 bool result;
12726 PyObject * obj0 = 0 ;
12727 char *kwnames[] = {
12728 (char *) "self", NULL
12729 };
12730
12731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12733 if (SWIG_arg_fail(1)) SWIG_fail;
12734 {
12735 PyThreadState* __tstate = wxPyBeginAllowThreads();
12736 result = (bool)(arg1)->HasV();
12737
12738 wxPyEndAllowThreads(__tstate);
12739 if (PyErr_Occurred()) SWIG_fail;
12740 }
12741 {
12742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12743 }
12744 return resultobj;
12745 fail:
12746 return NULL;
12747 }
12748
12749
12750 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12751 PyObject *resultobj;
12752 wxJoystick *arg1 = (wxJoystick *) 0 ;
12753 bool result;
12754 PyObject * obj0 = 0 ;
12755 char *kwnames[] = {
12756 (char *) "self", NULL
12757 };
12758
12759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12761 if (SWIG_arg_fail(1)) SWIG_fail;
12762 {
12763 PyThreadState* __tstate = wxPyBeginAllowThreads();
12764 result = (bool)(arg1)->HasPOV();
12765
12766 wxPyEndAllowThreads(__tstate);
12767 if (PyErr_Occurred()) SWIG_fail;
12768 }
12769 {
12770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12771 }
12772 return resultobj;
12773 fail:
12774 return NULL;
12775 }
12776
12777
12778 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12779 PyObject *resultobj;
12780 wxJoystick *arg1 = (wxJoystick *) 0 ;
12781 bool result;
12782 PyObject * obj0 = 0 ;
12783 char *kwnames[] = {
12784 (char *) "self", NULL
12785 };
12786
12787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12789 if (SWIG_arg_fail(1)) SWIG_fail;
12790 {
12791 PyThreadState* __tstate = wxPyBeginAllowThreads();
12792 result = (bool)(arg1)->HasPOV4Dir();
12793
12794 wxPyEndAllowThreads(__tstate);
12795 if (PyErr_Occurred()) SWIG_fail;
12796 }
12797 {
12798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12799 }
12800 return resultobj;
12801 fail:
12802 return NULL;
12803 }
12804
12805
12806 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12807 PyObject *resultobj;
12808 wxJoystick *arg1 = (wxJoystick *) 0 ;
12809 bool result;
12810 PyObject * obj0 = 0 ;
12811 char *kwnames[] = {
12812 (char *) "self", NULL
12813 };
12814
12815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12817 if (SWIG_arg_fail(1)) SWIG_fail;
12818 {
12819 PyThreadState* __tstate = wxPyBeginAllowThreads();
12820 result = (bool)(arg1)->HasPOVCTS();
12821
12822 wxPyEndAllowThreads(__tstate);
12823 if (PyErr_Occurred()) SWIG_fail;
12824 }
12825 {
12826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12827 }
12828 return resultobj;
12829 fail:
12830 return NULL;
12831 }
12832
12833
12834 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12835 PyObject *resultobj;
12836 wxJoystick *arg1 = (wxJoystick *) 0 ;
12837 wxWindow *arg2 = (wxWindow *) 0 ;
12838 int arg3 = (int) 0 ;
12839 bool result;
12840 PyObject * obj0 = 0 ;
12841 PyObject * obj1 = 0 ;
12842 PyObject * obj2 = 0 ;
12843 char *kwnames[] = {
12844 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12845 };
12846
12847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12849 if (SWIG_arg_fail(1)) SWIG_fail;
12850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12851 if (SWIG_arg_fail(2)) SWIG_fail;
12852 if (obj2) {
12853 {
12854 arg3 = (int)(SWIG_As_int(obj2));
12855 if (SWIG_arg_fail(3)) SWIG_fail;
12856 }
12857 }
12858 {
12859 PyThreadState* __tstate = wxPyBeginAllowThreads();
12860 result = (bool)(arg1)->SetCapture(arg2,arg3);
12861
12862 wxPyEndAllowThreads(__tstate);
12863 if (PyErr_Occurred()) SWIG_fail;
12864 }
12865 {
12866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12867 }
12868 return resultobj;
12869 fail:
12870 return NULL;
12871 }
12872
12873
12874 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12875 PyObject *resultobj;
12876 wxJoystick *arg1 = (wxJoystick *) 0 ;
12877 bool result;
12878 PyObject * obj0 = 0 ;
12879 char *kwnames[] = {
12880 (char *) "self", NULL
12881 };
12882
12883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12885 if (SWIG_arg_fail(1)) SWIG_fail;
12886 {
12887 PyThreadState* __tstate = wxPyBeginAllowThreads();
12888 result = (bool)(arg1)->ReleaseCapture();
12889
12890 wxPyEndAllowThreads(__tstate);
12891 if (PyErr_Occurred()) SWIG_fail;
12892 }
12893 {
12894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12895 }
12896 return resultobj;
12897 fail:
12898 return NULL;
12899 }
12900
12901
12902 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12903 PyObject *obj;
12904 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12905 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12906 Py_INCREF(obj);
12907 return Py_BuildValue((char *)"");
12908 }
12909 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12910 PyObject *resultobj;
12911 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12912 int arg2 = (int) 0 ;
12913 int arg3 = (int) wxJOYSTICK1 ;
12914 int arg4 = (int) 0 ;
12915 wxJoystickEvent *result;
12916 PyObject * obj0 = 0 ;
12917 PyObject * obj1 = 0 ;
12918 PyObject * obj2 = 0 ;
12919 PyObject * obj3 = 0 ;
12920 char *kwnames[] = {
12921 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12922 };
12923
12924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12925 if (obj0) {
12926 {
12927 arg1 = (wxEventType)(SWIG_As_int(obj0));
12928 if (SWIG_arg_fail(1)) SWIG_fail;
12929 }
12930 }
12931 if (obj1) {
12932 {
12933 arg2 = (int)(SWIG_As_int(obj1));
12934 if (SWIG_arg_fail(2)) SWIG_fail;
12935 }
12936 }
12937 if (obj2) {
12938 {
12939 arg3 = (int)(SWIG_As_int(obj2));
12940 if (SWIG_arg_fail(3)) SWIG_fail;
12941 }
12942 }
12943 if (obj3) {
12944 {
12945 arg4 = (int)(SWIG_As_int(obj3));
12946 if (SWIG_arg_fail(4)) SWIG_fail;
12947 }
12948 }
12949 {
12950 PyThreadState* __tstate = wxPyBeginAllowThreads();
12951 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12952
12953 wxPyEndAllowThreads(__tstate);
12954 if (PyErr_Occurred()) SWIG_fail;
12955 }
12956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12957 return resultobj;
12958 fail:
12959 return NULL;
12960 }
12961
12962
12963 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12964 PyObject *resultobj;
12965 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12966 wxPoint result;
12967 PyObject * obj0 = 0 ;
12968 char *kwnames[] = {
12969 (char *) "self", NULL
12970 };
12971
12972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12974 if (SWIG_arg_fail(1)) SWIG_fail;
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12978
12979 wxPyEndAllowThreads(__tstate);
12980 if (PyErr_Occurred()) SWIG_fail;
12981 }
12982 {
12983 wxPoint * resultptr;
12984 resultptr = new wxPoint((wxPoint &)(result));
12985 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12986 }
12987 return resultobj;
12988 fail:
12989 return NULL;
12990 }
12991
12992
12993 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12994 PyObject *resultobj;
12995 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12996 int result;
12997 PyObject * obj0 = 0 ;
12998 char *kwnames[] = {
12999 (char *) "self", NULL
13000 };
13001
13002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
13003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13004 if (SWIG_arg_fail(1)) SWIG_fail;
13005 {
13006 PyThreadState* __tstate = wxPyBeginAllowThreads();
13007 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
13008
13009 wxPyEndAllowThreads(__tstate);
13010 if (PyErr_Occurred()) SWIG_fail;
13011 }
13012 {
13013 resultobj = SWIG_From_int((int)(result));
13014 }
13015 return resultobj;
13016 fail:
13017 return NULL;
13018 }
13019
13020
13021 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13022 PyObject *resultobj;
13023 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13024 int result;
13025 PyObject * obj0 = 0 ;
13026 char *kwnames[] = {
13027 (char *) "self", NULL
13028 };
13029
13030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13032 if (SWIG_arg_fail(1)) SWIG_fail;
13033 {
13034 PyThreadState* __tstate = wxPyBeginAllowThreads();
13035 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13036
13037 wxPyEndAllowThreads(__tstate);
13038 if (PyErr_Occurred()) SWIG_fail;
13039 }
13040 {
13041 resultobj = SWIG_From_int((int)(result));
13042 }
13043 return resultobj;
13044 fail:
13045 return NULL;
13046 }
13047
13048
13049 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13050 PyObject *resultobj;
13051 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13052 int result;
13053 PyObject * obj0 = 0 ;
13054 char *kwnames[] = {
13055 (char *) "self", NULL
13056 };
13057
13058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13060 if (SWIG_arg_fail(1)) SWIG_fail;
13061 {
13062 PyThreadState* __tstate = wxPyBeginAllowThreads();
13063 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13064
13065 wxPyEndAllowThreads(__tstate);
13066 if (PyErr_Occurred()) SWIG_fail;
13067 }
13068 {
13069 resultobj = SWIG_From_int((int)(result));
13070 }
13071 return resultobj;
13072 fail:
13073 return NULL;
13074 }
13075
13076
13077 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13078 PyObject *resultobj;
13079 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13080 int result;
13081 PyObject * obj0 = 0 ;
13082 char *kwnames[] = {
13083 (char *) "self", NULL
13084 };
13085
13086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13088 if (SWIG_arg_fail(1)) SWIG_fail;
13089 {
13090 PyThreadState* __tstate = wxPyBeginAllowThreads();
13091 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13092
13093 wxPyEndAllowThreads(__tstate);
13094 if (PyErr_Occurred()) SWIG_fail;
13095 }
13096 {
13097 resultobj = SWIG_From_int((int)(result));
13098 }
13099 return resultobj;
13100 fail:
13101 return NULL;
13102 }
13103
13104
13105 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13106 PyObject *resultobj;
13107 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13108 int arg2 ;
13109 PyObject * obj0 = 0 ;
13110 PyObject * obj1 = 0 ;
13111 char *kwnames[] = {
13112 (char *) "self",(char *) "stick", NULL
13113 };
13114
13115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13117 if (SWIG_arg_fail(1)) SWIG_fail;
13118 {
13119 arg2 = (int)(SWIG_As_int(obj1));
13120 if (SWIG_arg_fail(2)) SWIG_fail;
13121 }
13122 {
13123 PyThreadState* __tstate = wxPyBeginAllowThreads();
13124 (arg1)->SetJoystick(arg2);
13125
13126 wxPyEndAllowThreads(__tstate);
13127 if (PyErr_Occurred()) SWIG_fail;
13128 }
13129 Py_INCREF(Py_None); resultobj = Py_None;
13130 return resultobj;
13131 fail:
13132 return NULL;
13133 }
13134
13135
13136 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13137 PyObject *resultobj;
13138 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13139 int arg2 ;
13140 PyObject * obj0 = 0 ;
13141 PyObject * obj1 = 0 ;
13142 char *kwnames[] = {
13143 (char *) "self",(char *) "state", NULL
13144 };
13145
13146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13148 if (SWIG_arg_fail(1)) SWIG_fail;
13149 {
13150 arg2 = (int)(SWIG_As_int(obj1));
13151 if (SWIG_arg_fail(2)) SWIG_fail;
13152 }
13153 {
13154 PyThreadState* __tstate = wxPyBeginAllowThreads();
13155 (arg1)->SetButtonState(arg2);
13156
13157 wxPyEndAllowThreads(__tstate);
13158 if (PyErr_Occurred()) SWIG_fail;
13159 }
13160 Py_INCREF(Py_None); resultobj = Py_None;
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13168 PyObject *resultobj;
13169 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13170 int arg2 ;
13171 PyObject * obj0 = 0 ;
13172 PyObject * obj1 = 0 ;
13173 char *kwnames[] = {
13174 (char *) "self",(char *) "change", NULL
13175 };
13176
13177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13179 if (SWIG_arg_fail(1)) SWIG_fail;
13180 {
13181 arg2 = (int)(SWIG_As_int(obj1));
13182 if (SWIG_arg_fail(2)) SWIG_fail;
13183 }
13184 {
13185 PyThreadState* __tstate = wxPyBeginAllowThreads();
13186 (arg1)->SetButtonChange(arg2);
13187
13188 wxPyEndAllowThreads(__tstate);
13189 if (PyErr_Occurred()) SWIG_fail;
13190 }
13191 Py_INCREF(Py_None); resultobj = Py_None;
13192 return resultobj;
13193 fail:
13194 return NULL;
13195 }
13196
13197
13198 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13199 PyObject *resultobj;
13200 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13201 wxPoint *arg2 = 0 ;
13202 wxPoint temp2 ;
13203 PyObject * obj0 = 0 ;
13204 PyObject * obj1 = 0 ;
13205 char *kwnames[] = {
13206 (char *) "self",(char *) "pos", NULL
13207 };
13208
13209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13211 if (SWIG_arg_fail(1)) SWIG_fail;
13212 {
13213 arg2 = &temp2;
13214 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13215 }
13216 {
13217 PyThreadState* __tstate = wxPyBeginAllowThreads();
13218 (arg1)->SetPosition((wxPoint const &)*arg2);
13219
13220 wxPyEndAllowThreads(__tstate);
13221 if (PyErr_Occurred()) SWIG_fail;
13222 }
13223 Py_INCREF(Py_None); resultobj = Py_None;
13224 return resultobj;
13225 fail:
13226 return NULL;
13227 }
13228
13229
13230 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13231 PyObject *resultobj;
13232 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13233 int arg2 ;
13234 PyObject * obj0 = 0 ;
13235 PyObject * obj1 = 0 ;
13236 char *kwnames[] = {
13237 (char *) "self",(char *) "zPos", NULL
13238 };
13239
13240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13242 if (SWIG_arg_fail(1)) SWIG_fail;
13243 {
13244 arg2 = (int)(SWIG_As_int(obj1));
13245 if (SWIG_arg_fail(2)) SWIG_fail;
13246 }
13247 {
13248 PyThreadState* __tstate = wxPyBeginAllowThreads();
13249 (arg1)->SetZPosition(arg2);
13250
13251 wxPyEndAllowThreads(__tstate);
13252 if (PyErr_Occurred()) SWIG_fail;
13253 }
13254 Py_INCREF(Py_None); resultobj = Py_None;
13255 return resultobj;
13256 fail:
13257 return NULL;
13258 }
13259
13260
13261 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13262 PyObject *resultobj;
13263 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13264 bool result;
13265 PyObject * obj0 = 0 ;
13266 char *kwnames[] = {
13267 (char *) "self", NULL
13268 };
13269
13270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13272 if (SWIG_arg_fail(1)) SWIG_fail;
13273 {
13274 PyThreadState* __tstate = wxPyBeginAllowThreads();
13275 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13276
13277 wxPyEndAllowThreads(__tstate);
13278 if (PyErr_Occurred()) SWIG_fail;
13279 }
13280 {
13281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13282 }
13283 return resultobj;
13284 fail:
13285 return NULL;
13286 }
13287
13288
13289 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13290 PyObject *resultobj;
13291 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13292 bool result;
13293 PyObject * obj0 = 0 ;
13294 char *kwnames[] = {
13295 (char *) "self", NULL
13296 };
13297
13298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13300 if (SWIG_arg_fail(1)) SWIG_fail;
13301 {
13302 PyThreadState* __tstate = wxPyBeginAllowThreads();
13303 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13304
13305 wxPyEndAllowThreads(__tstate);
13306 if (PyErr_Occurred()) SWIG_fail;
13307 }
13308 {
13309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13310 }
13311 return resultobj;
13312 fail:
13313 return NULL;
13314 }
13315
13316
13317 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13318 PyObject *resultobj;
13319 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13320 bool result;
13321 PyObject * obj0 = 0 ;
13322 char *kwnames[] = {
13323 (char *) "self", NULL
13324 };
13325
13326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13328 if (SWIG_arg_fail(1)) SWIG_fail;
13329 {
13330 PyThreadState* __tstate = wxPyBeginAllowThreads();
13331 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13332
13333 wxPyEndAllowThreads(__tstate);
13334 if (PyErr_Occurred()) SWIG_fail;
13335 }
13336 {
13337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13338 }
13339 return resultobj;
13340 fail:
13341 return NULL;
13342 }
13343
13344
13345 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13346 PyObject *resultobj;
13347 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13348 int arg2 = (int) wxJOY_BUTTON_ANY ;
13349 bool result;
13350 PyObject * obj0 = 0 ;
13351 PyObject * obj1 = 0 ;
13352 char *kwnames[] = {
13353 (char *) "self",(char *) "but", NULL
13354 };
13355
13356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13358 if (SWIG_arg_fail(1)) SWIG_fail;
13359 if (obj1) {
13360 {
13361 arg2 = (int)(SWIG_As_int(obj1));
13362 if (SWIG_arg_fail(2)) SWIG_fail;
13363 }
13364 }
13365 {
13366 PyThreadState* __tstate = wxPyBeginAllowThreads();
13367 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13368
13369 wxPyEndAllowThreads(__tstate);
13370 if (PyErr_Occurred()) SWIG_fail;
13371 }
13372 {
13373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13374 }
13375 return resultobj;
13376 fail:
13377 return NULL;
13378 }
13379
13380
13381 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13382 PyObject *resultobj;
13383 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13384 int arg2 = (int) wxJOY_BUTTON_ANY ;
13385 bool result;
13386 PyObject * obj0 = 0 ;
13387 PyObject * obj1 = 0 ;
13388 char *kwnames[] = {
13389 (char *) "self",(char *) "but", NULL
13390 };
13391
13392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13394 if (SWIG_arg_fail(1)) SWIG_fail;
13395 if (obj1) {
13396 {
13397 arg2 = (int)(SWIG_As_int(obj1));
13398 if (SWIG_arg_fail(2)) SWIG_fail;
13399 }
13400 }
13401 {
13402 PyThreadState* __tstate = wxPyBeginAllowThreads();
13403 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13404
13405 wxPyEndAllowThreads(__tstate);
13406 if (PyErr_Occurred()) SWIG_fail;
13407 }
13408 {
13409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13410 }
13411 return resultobj;
13412 fail:
13413 return NULL;
13414 }
13415
13416
13417 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13418 PyObject *resultobj;
13419 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13420 int arg2 = (int) wxJOY_BUTTON_ANY ;
13421 bool result;
13422 PyObject * obj0 = 0 ;
13423 PyObject * obj1 = 0 ;
13424 char *kwnames[] = {
13425 (char *) "self",(char *) "but", NULL
13426 };
13427
13428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13430 if (SWIG_arg_fail(1)) SWIG_fail;
13431 if (obj1) {
13432 {
13433 arg2 = (int)(SWIG_As_int(obj1));
13434 if (SWIG_arg_fail(2)) SWIG_fail;
13435 }
13436 }
13437 {
13438 PyThreadState* __tstate = wxPyBeginAllowThreads();
13439 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13440
13441 wxPyEndAllowThreads(__tstate);
13442 if (PyErr_Occurred()) SWIG_fail;
13443 }
13444 {
13445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13446 }
13447 return resultobj;
13448 fail:
13449 return NULL;
13450 }
13451
13452
13453 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13454 PyObject *obj;
13455 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13456 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13457 Py_INCREF(obj);
13458 return Py_BuildValue((char *)"");
13459 }
13460 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13461 PyObject *resultobj;
13462 wxString const &arg1_defvalue = wxPyEmptyString ;
13463 wxString *arg1 = (wxString *) &arg1_defvalue ;
13464 wxSound *result;
13465 bool temp1 = false ;
13466 PyObject * obj0 = 0 ;
13467 char *kwnames[] = {
13468 (char *) "fileName", NULL
13469 };
13470
13471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13472 if (obj0) {
13473 {
13474 arg1 = wxString_in_helper(obj0);
13475 if (arg1 == NULL) SWIG_fail;
13476 temp1 = true;
13477 }
13478 }
13479 {
13480 if (!wxPyCheckForApp()) SWIG_fail;
13481 PyThreadState* __tstate = wxPyBeginAllowThreads();
13482 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13483
13484 wxPyEndAllowThreads(__tstate);
13485 if (PyErr_Occurred()) SWIG_fail;
13486 }
13487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13488 {
13489 if (temp1)
13490 delete arg1;
13491 }
13492 return resultobj;
13493 fail:
13494 {
13495 if (temp1)
13496 delete arg1;
13497 }
13498 return NULL;
13499 }
13500
13501
13502 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13503 PyObject *resultobj;
13504 PyObject *arg1 = (PyObject *) 0 ;
13505 wxSound *result;
13506 PyObject * obj0 = 0 ;
13507 char *kwnames[] = {
13508 (char *) "data", NULL
13509 };
13510
13511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13512 arg1 = obj0;
13513 {
13514 if (!wxPyCheckForApp()) SWIG_fail;
13515 PyThreadState* __tstate = wxPyBeginAllowThreads();
13516 result = (wxSound *)new_wxSound(arg1);
13517
13518 wxPyEndAllowThreads(__tstate);
13519 if (PyErr_Occurred()) SWIG_fail;
13520 }
13521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13522 return resultobj;
13523 fail:
13524 return NULL;
13525 }
13526
13527
13528 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13529 PyObject *resultobj;
13530 wxSound *arg1 = (wxSound *) 0 ;
13531 PyObject * obj0 = 0 ;
13532 char *kwnames[] = {
13533 (char *) "self", NULL
13534 };
13535
13536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13538 if (SWIG_arg_fail(1)) SWIG_fail;
13539 {
13540 PyThreadState* __tstate = wxPyBeginAllowThreads();
13541 delete arg1;
13542
13543 wxPyEndAllowThreads(__tstate);
13544 if (PyErr_Occurred()) SWIG_fail;
13545 }
13546 Py_INCREF(Py_None); resultobj = Py_None;
13547 return resultobj;
13548 fail:
13549 return NULL;
13550 }
13551
13552
13553 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13554 PyObject *resultobj;
13555 wxSound *arg1 = (wxSound *) 0 ;
13556 wxString *arg2 = 0 ;
13557 bool result;
13558 bool temp2 = false ;
13559 PyObject * obj0 = 0 ;
13560 PyObject * obj1 = 0 ;
13561 char *kwnames[] = {
13562 (char *) "self",(char *) "fileName", NULL
13563 };
13564
13565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13567 if (SWIG_arg_fail(1)) SWIG_fail;
13568 {
13569 arg2 = wxString_in_helper(obj1);
13570 if (arg2 == NULL) SWIG_fail;
13571 temp2 = true;
13572 }
13573 {
13574 PyThreadState* __tstate = wxPyBeginAllowThreads();
13575 result = (bool)(arg1)->Create((wxString const &)*arg2);
13576
13577 wxPyEndAllowThreads(__tstate);
13578 if (PyErr_Occurred()) SWIG_fail;
13579 }
13580 {
13581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13582 }
13583 {
13584 if (temp2)
13585 delete arg2;
13586 }
13587 return resultobj;
13588 fail:
13589 {
13590 if (temp2)
13591 delete arg2;
13592 }
13593 return NULL;
13594 }
13595
13596
13597 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13598 PyObject *resultobj;
13599 wxSound *arg1 = (wxSound *) 0 ;
13600 PyObject *arg2 = (PyObject *) 0 ;
13601 bool result;
13602 PyObject * obj0 = 0 ;
13603 PyObject * obj1 = 0 ;
13604 char *kwnames[] = {
13605 (char *) "self",(char *) "data", NULL
13606 };
13607
13608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13610 if (SWIG_arg_fail(1)) SWIG_fail;
13611 arg2 = obj1;
13612 {
13613 PyThreadState* __tstate = wxPyBeginAllowThreads();
13614 result = (bool)wxSound_CreateFromData(arg1,arg2);
13615
13616 wxPyEndAllowThreads(__tstate);
13617 if (PyErr_Occurred()) SWIG_fail;
13618 }
13619 {
13620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13621 }
13622 return resultobj;
13623 fail:
13624 return NULL;
13625 }
13626
13627
13628 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13629 PyObject *resultobj;
13630 wxSound *arg1 = (wxSound *) 0 ;
13631 bool result;
13632 PyObject * obj0 = 0 ;
13633 char *kwnames[] = {
13634 (char *) "self", NULL
13635 };
13636
13637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13639 if (SWIG_arg_fail(1)) SWIG_fail;
13640 {
13641 PyThreadState* __tstate = wxPyBeginAllowThreads();
13642 result = (bool)(arg1)->IsOk();
13643
13644 wxPyEndAllowThreads(__tstate);
13645 if (PyErr_Occurred()) SWIG_fail;
13646 }
13647 {
13648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13649 }
13650 return resultobj;
13651 fail:
13652 return NULL;
13653 }
13654
13655
13656 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13657 PyObject *resultobj;
13658 wxSound *arg1 = (wxSound *) 0 ;
13659 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13660 bool result;
13661 PyObject * obj0 = 0 ;
13662 PyObject * obj1 = 0 ;
13663 char *kwnames[] = {
13664 (char *) "self",(char *) "flags", NULL
13665 };
13666
13667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13669 if (SWIG_arg_fail(1)) SWIG_fail;
13670 if (obj1) {
13671 {
13672 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13673 if (SWIG_arg_fail(2)) SWIG_fail;
13674 }
13675 }
13676 {
13677 if (!wxPyCheckForApp()) SWIG_fail;
13678 PyThreadState* __tstate = wxPyBeginAllowThreads();
13679 result = (bool)((wxSound const *)arg1)->Play(arg2);
13680
13681 wxPyEndAllowThreads(__tstate);
13682 if (PyErr_Occurred()) SWIG_fail;
13683 }
13684 {
13685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13686 }
13687 return resultobj;
13688 fail:
13689 return NULL;
13690 }
13691
13692
13693 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13694 PyObject *resultobj;
13695 wxString *arg1 = 0 ;
13696 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13697 bool result;
13698 bool temp1 = false ;
13699 PyObject * obj0 = 0 ;
13700 PyObject * obj1 = 0 ;
13701 char *kwnames[] = {
13702 (char *) "filename",(char *) "flags", NULL
13703 };
13704
13705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13706 {
13707 arg1 = wxString_in_helper(obj0);
13708 if (arg1 == NULL) SWIG_fail;
13709 temp1 = true;
13710 }
13711 if (obj1) {
13712 {
13713 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13714 if (SWIG_arg_fail(2)) SWIG_fail;
13715 }
13716 }
13717 {
13718 if (!wxPyCheckForApp()) SWIG_fail;
13719 PyThreadState* __tstate = wxPyBeginAllowThreads();
13720 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13721
13722 wxPyEndAllowThreads(__tstate);
13723 if (PyErr_Occurred()) SWIG_fail;
13724 }
13725 {
13726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13727 }
13728 {
13729 if (temp1)
13730 delete arg1;
13731 }
13732 return resultobj;
13733 fail:
13734 {
13735 if (temp1)
13736 delete arg1;
13737 }
13738 return NULL;
13739 }
13740
13741
13742 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13743 PyObject *resultobj;
13744 char *kwnames[] = {
13745 NULL
13746 };
13747
13748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13749 {
13750 if (!wxPyCheckForApp()) SWIG_fail;
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 wxSound::Stop();
13753
13754 wxPyEndAllowThreads(__tstate);
13755 if (PyErr_Occurred()) SWIG_fail;
13756 }
13757 Py_INCREF(Py_None); resultobj = Py_None;
13758 return resultobj;
13759 fail:
13760 return NULL;
13761 }
13762
13763
13764 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13765 PyObject *obj;
13766 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13767 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13768 Py_INCREF(obj);
13769 return Py_BuildValue((char *)"");
13770 }
13771 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13772 PyObject *resultobj;
13773 wxString *arg1 = 0 ;
13774 wxString *arg2 = 0 ;
13775 wxString *arg3 = 0 ;
13776 wxString *arg4 = 0 ;
13777 wxFileTypeInfo *result;
13778 bool temp1 = false ;
13779 bool temp2 = false ;
13780 bool temp3 = false ;
13781 bool temp4 = false ;
13782 PyObject * obj0 = 0 ;
13783 PyObject * obj1 = 0 ;
13784 PyObject * obj2 = 0 ;
13785 PyObject * obj3 = 0 ;
13786 char *kwnames[] = {
13787 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13788 };
13789
13790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13791 {
13792 arg1 = wxString_in_helper(obj0);
13793 if (arg1 == NULL) SWIG_fail;
13794 temp1 = true;
13795 }
13796 {
13797 arg2 = wxString_in_helper(obj1);
13798 if (arg2 == NULL) SWIG_fail;
13799 temp2 = true;
13800 }
13801 {
13802 arg3 = wxString_in_helper(obj2);
13803 if (arg3 == NULL) SWIG_fail;
13804 temp3 = true;
13805 }
13806 {
13807 arg4 = wxString_in_helper(obj3);
13808 if (arg4 == NULL) SWIG_fail;
13809 temp4 = true;
13810 }
13811 {
13812 PyThreadState* __tstate = wxPyBeginAllowThreads();
13813 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13814
13815 wxPyEndAllowThreads(__tstate);
13816 if (PyErr_Occurred()) SWIG_fail;
13817 }
13818 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13819 {
13820 if (temp1)
13821 delete arg1;
13822 }
13823 {
13824 if (temp2)
13825 delete arg2;
13826 }
13827 {
13828 if (temp3)
13829 delete arg3;
13830 }
13831 {
13832 if (temp4)
13833 delete arg4;
13834 }
13835 return resultobj;
13836 fail:
13837 {
13838 if (temp1)
13839 delete arg1;
13840 }
13841 {
13842 if (temp2)
13843 delete arg2;
13844 }
13845 {
13846 if (temp3)
13847 delete arg3;
13848 }
13849 {
13850 if (temp4)
13851 delete arg4;
13852 }
13853 return NULL;
13854 }
13855
13856
13857 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13858 PyObject *resultobj;
13859 wxArrayString *arg1 = 0 ;
13860 wxFileTypeInfo *result;
13861 bool temp1 = false ;
13862 PyObject * obj0 = 0 ;
13863 char *kwnames[] = {
13864 (char *) "sArray", NULL
13865 };
13866
13867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13868 {
13869 if (! PySequence_Check(obj0)) {
13870 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13871 SWIG_fail;
13872 }
13873 arg1 = new wxArrayString;
13874 temp1 = true;
13875 int i, len=PySequence_Length(obj0);
13876 for (i=0; i<len; i++) {
13877 PyObject* item = PySequence_GetItem(obj0, i);
13878 wxString* s = wxString_in_helper(item);
13879 if (PyErr_Occurred()) SWIG_fail;
13880 arg1->Add(*s);
13881 delete s;
13882 Py_DECREF(item);
13883 }
13884 }
13885 {
13886 PyThreadState* __tstate = wxPyBeginAllowThreads();
13887 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13888
13889 wxPyEndAllowThreads(__tstate);
13890 if (PyErr_Occurred()) SWIG_fail;
13891 }
13892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13893 {
13894 if (temp1) delete arg1;
13895 }
13896 return resultobj;
13897 fail:
13898 {
13899 if (temp1) delete arg1;
13900 }
13901 return NULL;
13902 }
13903
13904
13905 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13906 PyObject *resultobj;
13907 wxFileTypeInfo *result;
13908 char *kwnames[] = {
13909 NULL
13910 };
13911
13912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13913 {
13914 PyThreadState* __tstate = wxPyBeginAllowThreads();
13915 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13916
13917 wxPyEndAllowThreads(__tstate);
13918 if (PyErr_Occurred()) SWIG_fail;
13919 }
13920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13921 return resultobj;
13922 fail:
13923 return NULL;
13924 }
13925
13926
13927 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13928 PyObject *resultobj;
13929 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13930 bool result;
13931 PyObject * obj0 = 0 ;
13932 char *kwnames[] = {
13933 (char *) "self", NULL
13934 };
13935
13936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13938 if (SWIG_arg_fail(1)) SWIG_fail;
13939 {
13940 PyThreadState* __tstate = wxPyBeginAllowThreads();
13941 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13942
13943 wxPyEndAllowThreads(__tstate);
13944 if (PyErr_Occurred()) SWIG_fail;
13945 }
13946 {
13947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13948 }
13949 return resultobj;
13950 fail:
13951 return NULL;
13952 }
13953
13954
13955 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13956 PyObject *resultobj;
13957 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13958 wxString *arg2 = 0 ;
13959 int arg3 = (int) 0 ;
13960 bool temp2 = false ;
13961 PyObject * obj0 = 0 ;
13962 PyObject * obj1 = 0 ;
13963 PyObject * obj2 = 0 ;
13964 char *kwnames[] = {
13965 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13966 };
13967
13968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13970 if (SWIG_arg_fail(1)) SWIG_fail;
13971 {
13972 arg2 = wxString_in_helper(obj1);
13973 if (arg2 == NULL) SWIG_fail;
13974 temp2 = true;
13975 }
13976 if (obj2) {
13977 {
13978 arg3 = (int)(SWIG_As_int(obj2));
13979 if (SWIG_arg_fail(3)) SWIG_fail;
13980 }
13981 }
13982 {
13983 PyThreadState* __tstate = wxPyBeginAllowThreads();
13984 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13985
13986 wxPyEndAllowThreads(__tstate);
13987 if (PyErr_Occurred()) SWIG_fail;
13988 }
13989 Py_INCREF(Py_None); resultobj = Py_None;
13990 {
13991 if (temp2)
13992 delete arg2;
13993 }
13994 return resultobj;
13995 fail:
13996 {
13997 if (temp2)
13998 delete arg2;
13999 }
14000 return NULL;
14001 }
14002
14003
14004 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14005 PyObject *resultobj;
14006 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14007 wxString *arg2 = 0 ;
14008 bool temp2 = false ;
14009 PyObject * obj0 = 0 ;
14010 PyObject * obj1 = 0 ;
14011 char *kwnames[] = {
14012 (char *) "self",(char *) "shortDesc", NULL
14013 };
14014
14015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14017 if (SWIG_arg_fail(1)) SWIG_fail;
14018 {
14019 arg2 = wxString_in_helper(obj1);
14020 if (arg2 == NULL) SWIG_fail;
14021 temp2 = true;
14022 }
14023 {
14024 PyThreadState* __tstate = wxPyBeginAllowThreads();
14025 (arg1)->SetShortDesc((wxString const &)*arg2);
14026
14027 wxPyEndAllowThreads(__tstate);
14028 if (PyErr_Occurred()) SWIG_fail;
14029 }
14030 Py_INCREF(Py_None); resultobj = Py_None;
14031 {
14032 if (temp2)
14033 delete arg2;
14034 }
14035 return resultobj;
14036 fail:
14037 {
14038 if (temp2)
14039 delete arg2;
14040 }
14041 return NULL;
14042 }
14043
14044
14045 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14046 PyObject *resultobj;
14047 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14048 wxString *result;
14049 PyObject * obj0 = 0 ;
14050 char *kwnames[] = {
14051 (char *) "self", NULL
14052 };
14053
14054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14056 if (SWIG_arg_fail(1)) SWIG_fail;
14057 {
14058 PyThreadState* __tstate = wxPyBeginAllowThreads();
14059 {
14060 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14061 result = (wxString *) &_result_ref;
14062 }
14063
14064 wxPyEndAllowThreads(__tstate);
14065 if (PyErr_Occurred()) SWIG_fail;
14066 }
14067 {
14068 #if wxUSE_UNICODE
14069 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14070 #else
14071 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14072 #endif
14073 }
14074 return resultobj;
14075 fail:
14076 return NULL;
14077 }
14078
14079
14080 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14081 PyObject *resultobj;
14082 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14083 wxString *result;
14084 PyObject * obj0 = 0 ;
14085 char *kwnames[] = {
14086 (char *) "self", NULL
14087 };
14088
14089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14091 if (SWIG_arg_fail(1)) SWIG_fail;
14092 {
14093 PyThreadState* __tstate = wxPyBeginAllowThreads();
14094 {
14095 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14096 result = (wxString *) &_result_ref;
14097 }
14098
14099 wxPyEndAllowThreads(__tstate);
14100 if (PyErr_Occurred()) SWIG_fail;
14101 }
14102 {
14103 #if wxUSE_UNICODE
14104 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14105 #else
14106 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14107 #endif
14108 }
14109 return resultobj;
14110 fail:
14111 return NULL;
14112 }
14113
14114
14115 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14116 PyObject *resultobj;
14117 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14118 wxString *result;
14119 PyObject * obj0 = 0 ;
14120 char *kwnames[] = {
14121 (char *) "self", NULL
14122 };
14123
14124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14126 if (SWIG_arg_fail(1)) SWIG_fail;
14127 {
14128 PyThreadState* __tstate = wxPyBeginAllowThreads();
14129 {
14130 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14131 result = (wxString *) &_result_ref;
14132 }
14133
14134 wxPyEndAllowThreads(__tstate);
14135 if (PyErr_Occurred()) SWIG_fail;
14136 }
14137 {
14138 #if wxUSE_UNICODE
14139 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14140 #else
14141 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14142 #endif
14143 }
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj;
14152 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14153 wxString *result;
14154 PyObject * obj0 = 0 ;
14155 char *kwnames[] = {
14156 (char *) "self", NULL
14157 };
14158
14159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14161 if (SWIG_arg_fail(1)) SWIG_fail;
14162 {
14163 PyThreadState* __tstate = wxPyBeginAllowThreads();
14164 {
14165 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14166 result = (wxString *) &_result_ref;
14167 }
14168
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 {
14173 #if wxUSE_UNICODE
14174 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14175 #else
14176 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14177 #endif
14178 }
14179 return resultobj;
14180 fail:
14181 return NULL;
14182 }
14183
14184
14185 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14186 PyObject *resultobj;
14187 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14188 wxString *result;
14189 PyObject * obj0 = 0 ;
14190 char *kwnames[] = {
14191 (char *) "self", NULL
14192 };
14193
14194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14196 if (SWIG_arg_fail(1)) SWIG_fail;
14197 {
14198 PyThreadState* __tstate = wxPyBeginAllowThreads();
14199 {
14200 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14201 result = (wxString *) &_result_ref;
14202 }
14203
14204 wxPyEndAllowThreads(__tstate);
14205 if (PyErr_Occurred()) SWIG_fail;
14206 }
14207 {
14208 #if wxUSE_UNICODE
14209 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14210 #else
14211 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14212 #endif
14213 }
14214 return resultobj;
14215 fail:
14216 return NULL;
14217 }
14218
14219
14220 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14221 PyObject *resultobj;
14222 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14223 wxArrayString *result;
14224 PyObject * obj0 = 0 ;
14225 char *kwnames[] = {
14226 (char *) "self", NULL
14227 };
14228
14229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14231 if (SWIG_arg_fail(1)) SWIG_fail;
14232 {
14233 PyThreadState* __tstate = wxPyBeginAllowThreads();
14234 {
14235 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14236 result = (wxArrayString *) &_result_ref;
14237 }
14238
14239 wxPyEndAllowThreads(__tstate);
14240 if (PyErr_Occurred()) SWIG_fail;
14241 }
14242 {
14243 resultobj = wxArrayString2PyList_helper(*result);
14244 }
14245 return resultobj;
14246 fail:
14247 return NULL;
14248 }
14249
14250
14251 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14252 PyObject *resultobj;
14253 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14254 int result;
14255 PyObject * obj0 = 0 ;
14256 char *kwnames[] = {
14257 (char *) "self", NULL
14258 };
14259
14260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14262 if (SWIG_arg_fail(1)) SWIG_fail;
14263 {
14264 PyThreadState* __tstate = wxPyBeginAllowThreads();
14265 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14266
14267 wxPyEndAllowThreads(__tstate);
14268 if (PyErr_Occurred()) SWIG_fail;
14269 }
14270 {
14271 resultobj = SWIG_From_int((int)(result));
14272 }
14273 return resultobj;
14274 fail:
14275 return NULL;
14276 }
14277
14278
14279 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14280 PyObject *resultobj;
14281 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14282 wxString *result;
14283 PyObject * obj0 = 0 ;
14284 char *kwnames[] = {
14285 (char *) "self", NULL
14286 };
14287
14288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14290 if (SWIG_arg_fail(1)) SWIG_fail;
14291 {
14292 PyThreadState* __tstate = wxPyBeginAllowThreads();
14293 {
14294 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14295 result = (wxString *) &_result_ref;
14296 }
14297
14298 wxPyEndAllowThreads(__tstate);
14299 if (PyErr_Occurred()) SWIG_fail;
14300 }
14301 {
14302 #if wxUSE_UNICODE
14303 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14304 #else
14305 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14306 #endif
14307 }
14308 return resultobj;
14309 fail:
14310 return NULL;
14311 }
14312
14313
14314 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14315 PyObject *resultobj;
14316 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14317 int result;
14318 PyObject * obj0 = 0 ;
14319 char *kwnames[] = {
14320 (char *) "self", NULL
14321 };
14322
14323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14325 if (SWIG_arg_fail(1)) SWIG_fail;
14326 {
14327 PyThreadState* __tstate = wxPyBeginAllowThreads();
14328 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14329
14330 wxPyEndAllowThreads(__tstate);
14331 if (PyErr_Occurred()) SWIG_fail;
14332 }
14333 {
14334 resultobj = SWIG_From_int((int)(result));
14335 }
14336 return resultobj;
14337 fail:
14338 return NULL;
14339 }
14340
14341
14342 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14343 PyObject *obj;
14344 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14345 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14346 Py_INCREF(obj);
14347 return Py_BuildValue((char *)"");
14348 }
14349 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14350 PyObject *resultobj;
14351 wxFileTypeInfo *arg1 = 0 ;
14352 wxFileType *result;
14353 PyObject * obj0 = 0 ;
14354 char *kwnames[] = {
14355 (char *) "ftInfo", NULL
14356 };
14357
14358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14359 {
14360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14361 if (SWIG_arg_fail(1)) SWIG_fail;
14362 if (arg1 == NULL) {
14363 SWIG_null_ref("wxFileTypeInfo");
14364 }
14365 if (SWIG_arg_fail(1)) SWIG_fail;
14366 }
14367 {
14368 PyThreadState* __tstate = wxPyBeginAllowThreads();
14369 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14370
14371 wxPyEndAllowThreads(__tstate);
14372 if (PyErr_Occurred()) SWIG_fail;
14373 }
14374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14375 return resultobj;
14376 fail:
14377 return NULL;
14378 }
14379
14380
14381 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14382 PyObject *resultobj;
14383 wxFileType *arg1 = (wxFileType *) 0 ;
14384 PyObject * obj0 = 0 ;
14385 char *kwnames[] = {
14386 (char *) "self", NULL
14387 };
14388
14389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14391 if (SWIG_arg_fail(1)) SWIG_fail;
14392 {
14393 PyThreadState* __tstate = wxPyBeginAllowThreads();
14394 delete arg1;
14395
14396 wxPyEndAllowThreads(__tstate);
14397 if (PyErr_Occurred()) SWIG_fail;
14398 }
14399 Py_INCREF(Py_None); resultobj = Py_None;
14400 return resultobj;
14401 fail:
14402 return NULL;
14403 }
14404
14405
14406 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14407 PyObject *resultobj;
14408 wxFileType *arg1 = (wxFileType *) 0 ;
14409 PyObject *result;
14410 PyObject * obj0 = 0 ;
14411 char *kwnames[] = {
14412 (char *) "self", NULL
14413 };
14414
14415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14417 if (SWIG_arg_fail(1)) SWIG_fail;
14418 {
14419 PyThreadState* __tstate = wxPyBeginAllowThreads();
14420 result = (PyObject *)wxFileType_GetMimeType(arg1);
14421
14422 wxPyEndAllowThreads(__tstate);
14423 if (PyErr_Occurred()) SWIG_fail;
14424 }
14425 resultobj = result;
14426 return resultobj;
14427 fail:
14428 return NULL;
14429 }
14430
14431
14432 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14433 PyObject *resultobj;
14434 wxFileType *arg1 = (wxFileType *) 0 ;
14435 PyObject *result;
14436 PyObject * obj0 = 0 ;
14437 char *kwnames[] = {
14438 (char *) "self", NULL
14439 };
14440
14441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14443 if (SWIG_arg_fail(1)) SWIG_fail;
14444 {
14445 PyThreadState* __tstate = wxPyBeginAllowThreads();
14446 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14447
14448 wxPyEndAllowThreads(__tstate);
14449 if (PyErr_Occurred()) SWIG_fail;
14450 }
14451 resultobj = result;
14452 return resultobj;
14453 fail:
14454 return NULL;
14455 }
14456
14457
14458 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14459 PyObject *resultobj;
14460 wxFileType *arg1 = (wxFileType *) 0 ;
14461 PyObject *result;
14462 PyObject * obj0 = 0 ;
14463 char *kwnames[] = {
14464 (char *) "self", NULL
14465 };
14466
14467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14469 if (SWIG_arg_fail(1)) SWIG_fail;
14470 {
14471 PyThreadState* __tstate = wxPyBeginAllowThreads();
14472 result = (PyObject *)wxFileType_GetExtensions(arg1);
14473
14474 wxPyEndAllowThreads(__tstate);
14475 if (PyErr_Occurred()) SWIG_fail;
14476 }
14477 resultobj = result;
14478 return resultobj;
14479 fail:
14480 return NULL;
14481 }
14482
14483
14484 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14485 PyObject *resultobj;
14486 wxFileType *arg1 = (wxFileType *) 0 ;
14487 wxIcon *result;
14488 PyObject * obj0 = 0 ;
14489 char *kwnames[] = {
14490 (char *) "self", NULL
14491 };
14492
14493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14495 if (SWIG_arg_fail(1)) SWIG_fail;
14496 {
14497 PyThreadState* __tstate = wxPyBeginAllowThreads();
14498 result = (wxIcon *)wxFileType_GetIcon(arg1);
14499
14500 wxPyEndAllowThreads(__tstate);
14501 if (PyErr_Occurred()) SWIG_fail;
14502 }
14503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14504 return resultobj;
14505 fail:
14506 return NULL;
14507 }
14508
14509
14510 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14511 PyObject *resultobj;
14512 wxFileType *arg1 = (wxFileType *) 0 ;
14513 PyObject *result;
14514 PyObject * obj0 = 0 ;
14515 char *kwnames[] = {
14516 (char *) "self", NULL
14517 };
14518
14519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14521 if (SWIG_arg_fail(1)) SWIG_fail;
14522 {
14523 PyThreadState* __tstate = wxPyBeginAllowThreads();
14524 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14525
14526 wxPyEndAllowThreads(__tstate);
14527 if (PyErr_Occurred()) SWIG_fail;
14528 }
14529 resultobj = result;
14530 return resultobj;
14531 fail:
14532 return NULL;
14533 }
14534
14535
14536 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14537 PyObject *resultobj;
14538 wxFileType *arg1 = (wxFileType *) 0 ;
14539 PyObject *result;
14540 PyObject * obj0 = 0 ;
14541 char *kwnames[] = {
14542 (char *) "self", NULL
14543 };
14544
14545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14547 if (SWIG_arg_fail(1)) SWIG_fail;
14548 {
14549 PyThreadState* __tstate = wxPyBeginAllowThreads();
14550 result = (PyObject *)wxFileType_GetDescription(arg1);
14551
14552 wxPyEndAllowThreads(__tstate);
14553 if (PyErr_Occurred()) SWIG_fail;
14554 }
14555 resultobj = result;
14556 return resultobj;
14557 fail:
14558 return NULL;
14559 }
14560
14561
14562 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14563 PyObject *resultobj;
14564 wxFileType *arg1 = (wxFileType *) 0 ;
14565 wxString *arg2 = 0 ;
14566 wxString const &arg3_defvalue = wxPyEmptyString ;
14567 wxString *arg3 = (wxString *) &arg3_defvalue ;
14568 PyObject *result;
14569 bool temp2 = false ;
14570 bool temp3 = false ;
14571 PyObject * obj0 = 0 ;
14572 PyObject * obj1 = 0 ;
14573 PyObject * obj2 = 0 ;
14574 char *kwnames[] = {
14575 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14576 };
14577
14578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14580 if (SWIG_arg_fail(1)) SWIG_fail;
14581 {
14582 arg2 = wxString_in_helper(obj1);
14583 if (arg2 == NULL) SWIG_fail;
14584 temp2 = true;
14585 }
14586 if (obj2) {
14587 {
14588 arg3 = wxString_in_helper(obj2);
14589 if (arg3 == NULL) SWIG_fail;
14590 temp3 = true;
14591 }
14592 }
14593 {
14594 PyThreadState* __tstate = wxPyBeginAllowThreads();
14595 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14596
14597 wxPyEndAllowThreads(__tstate);
14598 if (PyErr_Occurred()) SWIG_fail;
14599 }
14600 resultobj = result;
14601 {
14602 if (temp2)
14603 delete arg2;
14604 }
14605 {
14606 if (temp3)
14607 delete arg3;
14608 }
14609 return resultobj;
14610 fail:
14611 {
14612 if (temp2)
14613 delete arg2;
14614 }
14615 {
14616 if (temp3)
14617 delete arg3;
14618 }
14619 return NULL;
14620 }
14621
14622
14623 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14624 PyObject *resultobj;
14625 wxFileType *arg1 = (wxFileType *) 0 ;
14626 wxString *arg2 = 0 ;
14627 wxString const &arg3_defvalue = wxPyEmptyString ;
14628 wxString *arg3 = (wxString *) &arg3_defvalue ;
14629 PyObject *result;
14630 bool temp2 = false ;
14631 bool temp3 = false ;
14632 PyObject * obj0 = 0 ;
14633 PyObject * obj1 = 0 ;
14634 PyObject * obj2 = 0 ;
14635 char *kwnames[] = {
14636 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14637 };
14638
14639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14641 if (SWIG_arg_fail(1)) SWIG_fail;
14642 {
14643 arg2 = wxString_in_helper(obj1);
14644 if (arg2 == NULL) SWIG_fail;
14645 temp2 = true;
14646 }
14647 if (obj2) {
14648 {
14649 arg3 = wxString_in_helper(obj2);
14650 if (arg3 == NULL) SWIG_fail;
14651 temp3 = true;
14652 }
14653 }
14654 {
14655 PyThreadState* __tstate = wxPyBeginAllowThreads();
14656 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14657
14658 wxPyEndAllowThreads(__tstate);
14659 if (PyErr_Occurred()) SWIG_fail;
14660 }
14661 resultobj = result;
14662 {
14663 if (temp2)
14664 delete arg2;
14665 }
14666 {
14667 if (temp3)
14668 delete arg3;
14669 }
14670 return resultobj;
14671 fail:
14672 {
14673 if (temp2)
14674 delete arg2;
14675 }
14676 {
14677 if (temp3)
14678 delete arg3;
14679 }
14680 return NULL;
14681 }
14682
14683
14684 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14685 PyObject *resultobj;
14686 wxFileType *arg1 = (wxFileType *) 0 ;
14687 wxString *arg2 = 0 ;
14688 wxString const &arg3_defvalue = wxPyEmptyString ;
14689 wxString *arg3 = (wxString *) &arg3_defvalue ;
14690 PyObject *result;
14691 bool temp2 = false ;
14692 bool temp3 = false ;
14693 PyObject * obj0 = 0 ;
14694 PyObject * obj1 = 0 ;
14695 PyObject * obj2 = 0 ;
14696 char *kwnames[] = {
14697 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14698 };
14699
14700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14702 if (SWIG_arg_fail(1)) SWIG_fail;
14703 {
14704 arg2 = wxString_in_helper(obj1);
14705 if (arg2 == NULL) SWIG_fail;
14706 temp2 = true;
14707 }
14708 if (obj2) {
14709 {
14710 arg3 = wxString_in_helper(obj2);
14711 if (arg3 == NULL) SWIG_fail;
14712 temp3 = true;
14713 }
14714 }
14715 {
14716 PyThreadState* __tstate = wxPyBeginAllowThreads();
14717 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14718
14719 wxPyEndAllowThreads(__tstate);
14720 if (PyErr_Occurred()) SWIG_fail;
14721 }
14722 resultobj = result;
14723 {
14724 if (temp2)
14725 delete arg2;
14726 }
14727 {
14728 if (temp3)
14729 delete arg3;
14730 }
14731 return resultobj;
14732 fail:
14733 {
14734 if (temp2)
14735 delete arg2;
14736 }
14737 {
14738 if (temp3)
14739 delete arg3;
14740 }
14741 return NULL;
14742 }
14743
14744
14745 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14746 PyObject *resultobj;
14747 wxFileType *arg1 = (wxFileType *) 0 ;
14748 wxString *arg2 = 0 ;
14749 wxString *arg3 = 0 ;
14750 bool arg4 = (bool) true ;
14751 bool result;
14752 bool temp2 = false ;
14753 bool temp3 = false ;
14754 PyObject * obj0 = 0 ;
14755 PyObject * obj1 = 0 ;
14756 PyObject * obj2 = 0 ;
14757 PyObject * obj3 = 0 ;
14758 char *kwnames[] = {
14759 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14760 };
14761
14762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14764 if (SWIG_arg_fail(1)) SWIG_fail;
14765 {
14766 arg2 = wxString_in_helper(obj1);
14767 if (arg2 == NULL) SWIG_fail;
14768 temp2 = true;
14769 }
14770 {
14771 arg3 = wxString_in_helper(obj2);
14772 if (arg3 == NULL) SWIG_fail;
14773 temp3 = true;
14774 }
14775 if (obj3) {
14776 {
14777 arg4 = (bool)(SWIG_As_bool(obj3));
14778 if (SWIG_arg_fail(4)) SWIG_fail;
14779 }
14780 }
14781 {
14782 PyThreadState* __tstate = wxPyBeginAllowThreads();
14783 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14784
14785 wxPyEndAllowThreads(__tstate);
14786 if (PyErr_Occurred()) SWIG_fail;
14787 }
14788 {
14789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14790 }
14791 {
14792 if (temp2)
14793 delete arg2;
14794 }
14795 {
14796 if (temp3)
14797 delete arg3;
14798 }
14799 return resultobj;
14800 fail:
14801 {
14802 if (temp2)
14803 delete arg2;
14804 }
14805 {
14806 if (temp3)
14807 delete arg3;
14808 }
14809 return NULL;
14810 }
14811
14812
14813 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14814 PyObject *resultobj;
14815 wxFileType *arg1 = (wxFileType *) 0 ;
14816 wxString const &arg2_defvalue = wxPyEmptyString ;
14817 wxString *arg2 = (wxString *) &arg2_defvalue ;
14818 int arg3 = (int) 0 ;
14819 bool result;
14820 bool temp2 = false ;
14821 PyObject * obj0 = 0 ;
14822 PyObject * obj1 = 0 ;
14823 PyObject * obj2 = 0 ;
14824 char *kwnames[] = {
14825 (char *) "self",(char *) "cmd",(char *) "index", NULL
14826 };
14827
14828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14830 if (SWIG_arg_fail(1)) SWIG_fail;
14831 if (obj1) {
14832 {
14833 arg2 = wxString_in_helper(obj1);
14834 if (arg2 == NULL) SWIG_fail;
14835 temp2 = true;
14836 }
14837 }
14838 if (obj2) {
14839 {
14840 arg3 = (int)(SWIG_As_int(obj2));
14841 if (SWIG_arg_fail(3)) SWIG_fail;
14842 }
14843 }
14844 {
14845 PyThreadState* __tstate = wxPyBeginAllowThreads();
14846 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14847
14848 wxPyEndAllowThreads(__tstate);
14849 if (PyErr_Occurred()) SWIG_fail;
14850 }
14851 {
14852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14853 }
14854 {
14855 if (temp2)
14856 delete arg2;
14857 }
14858 return resultobj;
14859 fail:
14860 {
14861 if (temp2)
14862 delete arg2;
14863 }
14864 return NULL;
14865 }
14866
14867
14868 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14869 PyObject *resultobj;
14870 wxFileType *arg1 = (wxFileType *) 0 ;
14871 bool result;
14872 PyObject * obj0 = 0 ;
14873 char *kwnames[] = {
14874 (char *) "self", NULL
14875 };
14876
14877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14879 if (SWIG_arg_fail(1)) SWIG_fail;
14880 {
14881 PyThreadState* __tstate = wxPyBeginAllowThreads();
14882 result = (bool)(arg1)->Unassociate();
14883
14884 wxPyEndAllowThreads(__tstate);
14885 if (PyErr_Occurred()) SWIG_fail;
14886 }
14887 {
14888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14889 }
14890 return resultobj;
14891 fail:
14892 return NULL;
14893 }
14894
14895
14896 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14897 PyObject *resultobj;
14898 wxString *arg1 = 0 ;
14899 wxString *arg2 = 0 ;
14900 wxString const &arg3_defvalue = wxPyEmptyString ;
14901 wxString *arg3 = (wxString *) &arg3_defvalue ;
14902 wxString result;
14903 bool temp1 = false ;
14904 bool temp2 = false ;
14905 bool temp3 = false ;
14906 PyObject * obj0 = 0 ;
14907 PyObject * obj1 = 0 ;
14908 PyObject * obj2 = 0 ;
14909 char *kwnames[] = {
14910 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14911 };
14912
14913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14914 {
14915 arg1 = wxString_in_helper(obj0);
14916 if (arg1 == NULL) SWIG_fail;
14917 temp1 = true;
14918 }
14919 {
14920 arg2 = wxString_in_helper(obj1);
14921 if (arg2 == NULL) SWIG_fail;
14922 temp2 = true;
14923 }
14924 if (obj2) {
14925 {
14926 arg3 = wxString_in_helper(obj2);
14927 if (arg3 == NULL) SWIG_fail;
14928 temp3 = true;
14929 }
14930 }
14931 {
14932 PyThreadState* __tstate = wxPyBeginAllowThreads();
14933 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14934
14935 wxPyEndAllowThreads(__tstate);
14936 if (PyErr_Occurred()) SWIG_fail;
14937 }
14938 {
14939 #if wxUSE_UNICODE
14940 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14941 #else
14942 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14943 #endif
14944 }
14945 {
14946 if (temp1)
14947 delete arg1;
14948 }
14949 {
14950 if (temp2)
14951 delete arg2;
14952 }
14953 {
14954 if (temp3)
14955 delete arg3;
14956 }
14957 return resultobj;
14958 fail:
14959 {
14960 if (temp1)
14961 delete arg1;
14962 }
14963 {
14964 if (temp2)
14965 delete arg2;
14966 }
14967 {
14968 if (temp3)
14969 delete arg3;
14970 }
14971 return NULL;
14972 }
14973
14974
14975 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14976 PyObject *obj;
14977 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14978 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14979 Py_INCREF(obj);
14980 return Py_BuildValue((char *)"");
14981 }
14982 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14983 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14984 return 1;
14985 }
14986
14987
14988 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14989 PyObject *pyobj;
14990
14991 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14992 return pyobj;
14993 }
14994
14995
14996 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14997 PyObject *resultobj;
14998 wxString *arg1 = 0 ;
14999 wxString *arg2 = 0 ;
15000 bool result;
15001 bool temp1 = false ;
15002 bool temp2 = false ;
15003 PyObject * obj0 = 0 ;
15004 PyObject * obj1 = 0 ;
15005 char *kwnames[] = {
15006 (char *) "mimeType",(char *) "wildcard", NULL
15007 };
15008
15009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15010 {
15011 arg1 = wxString_in_helper(obj0);
15012 if (arg1 == NULL) SWIG_fail;
15013 temp1 = true;
15014 }
15015 {
15016 arg2 = wxString_in_helper(obj1);
15017 if (arg2 == NULL) SWIG_fail;
15018 temp2 = true;
15019 }
15020 {
15021 PyThreadState* __tstate = wxPyBeginAllowThreads();
15022 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15023
15024 wxPyEndAllowThreads(__tstate);
15025 if (PyErr_Occurred()) SWIG_fail;
15026 }
15027 {
15028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15029 }
15030 {
15031 if (temp1)
15032 delete arg1;
15033 }
15034 {
15035 if (temp2)
15036 delete arg2;
15037 }
15038 return resultobj;
15039 fail:
15040 {
15041 if (temp1)
15042 delete arg1;
15043 }
15044 {
15045 if (temp2)
15046 delete arg2;
15047 }
15048 return NULL;
15049 }
15050
15051
15052 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15053 PyObject *resultobj;
15054 wxMimeTypesManager *result;
15055 char *kwnames[] = {
15056 NULL
15057 };
15058
15059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15060 {
15061 PyThreadState* __tstate = wxPyBeginAllowThreads();
15062 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15063
15064 wxPyEndAllowThreads(__tstate);
15065 if (PyErr_Occurred()) SWIG_fail;
15066 }
15067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15068 return resultobj;
15069 fail:
15070 return NULL;
15071 }
15072
15073
15074 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15075 PyObject *resultobj;
15076 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15077 int arg2 = (int) wxMAILCAP_ALL ;
15078 wxString const &arg3_defvalue = wxPyEmptyString ;
15079 wxString *arg3 = (wxString *) &arg3_defvalue ;
15080 bool temp3 = false ;
15081 PyObject * obj0 = 0 ;
15082 PyObject * obj1 = 0 ;
15083 PyObject * obj2 = 0 ;
15084 char *kwnames[] = {
15085 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15086 };
15087
15088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15090 if (SWIG_arg_fail(1)) SWIG_fail;
15091 if (obj1) {
15092 {
15093 arg2 = (int)(SWIG_As_int(obj1));
15094 if (SWIG_arg_fail(2)) SWIG_fail;
15095 }
15096 }
15097 if (obj2) {
15098 {
15099 arg3 = wxString_in_helper(obj2);
15100 if (arg3 == NULL) SWIG_fail;
15101 temp3 = true;
15102 }
15103 }
15104 {
15105 PyThreadState* __tstate = wxPyBeginAllowThreads();
15106 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15107
15108 wxPyEndAllowThreads(__tstate);
15109 if (PyErr_Occurred()) SWIG_fail;
15110 }
15111 Py_INCREF(Py_None); resultobj = Py_None;
15112 {
15113 if (temp3)
15114 delete arg3;
15115 }
15116 return resultobj;
15117 fail:
15118 {
15119 if (temp3)
15120 delete arg3;
15121 }
15122 return NULL;
15123 }
15124
15125
15126 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15127 PyObject *resultobj;
15128 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15129 PyObject * obj0 = 0 ;
15130 char *kwnames[] = {
15131 (char *) "self", NULL
15132 };
15133
15134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15136 if (SWIG_arg_fail(1)) SWIG_fail;
15137 {
15138 PyThreadState* __tstate = wxPyBeginAllowThreads();
15139 (arg1)->ClearData();
15140
15141 wxPyEndAllowThreads(__tstate);
15142 if (PyErr_Occurred()) SWIG_fail;
15143 }
15144 Py_INCREF(Py_None); resultobj = Py_None;
15145 return resultobj;
15146 fail:
15147 return NULL;
15148 }
15149
15150
15151 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15152 PyObject *resultobj;
15153 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15154 wxString *arg2 = 0 ;
15155 wxFileType *result;
15156 bool temp2 = false ;
15157 PyObject * obj0 = 0 ;
15158 PyObject * obj1 = 0 ;
15159 char *kwnames[] = {
15160 (char *) "self",(char *) "ext", NULL
15161 };
15162
15163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15165 if (SWIG_arg_fail(1)) SWIG_fail;
15166 {
15167 arg2 = wxString_in_helper(obj1);
15168 if (arg2 == NULL) SWIG_fail;
15169 temp2 = true;
15170 }
15171 {
15172 PyThreadState* __tstate = wxPyBeginAllowThreads();
15173 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15174
15175 wxPyEndAllowThreads(__tstate);
15176 if (PyErr_Occurred()) SWIG_fail;
15177 }
15178 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15179 {
15180 if (temp2)
15181 delete arg2;
15182 }
15183 return resultobj;
15184 fail:
15185 {
15186 if (temp2)
15187 delete arg2;
15188 }
15189 return NULL;
15190 }
15191
15192
15193 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15194 PyObject *resultobj;
15195 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15196 wxString *arg2 = 0 ;
15197 wxFileType *result;
15198 bool temp2 = false ;
15199 PyObject * obj0 = 0 ;
15200 PyObject * obj1 = 0 ;
15201 char *kwnames[] = {
15202 (char *) "self",(char *) "mimeType", NULL
15203 };
15204
15205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15207 if (SWIG_arg_fail(1)) SWIG_fail;
15208 {
15209 arg2 = wxString_in_helper(obj1);
15210 if (arg2 == NULL) SWIG_fail;
15211 temp2 = true;
15212 }
15213 {
15214 PyThreadState* __tstate = wxPyBeginAllowThreads();
15215 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15216
15217 wxPyEndAllowThreads(__tstate);
15218 if (PyErr_Occurred()) SWIG_fail;
15219 }
15220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15221 {
15222 if (temp2)
15223 delete arg2;
15224 }
15225 return resultobj;
15226 fail:
15227 {
15228 if (temp2)
15229 delete arg2;
15230 }
15231 return NULL;
15232 }
15233
15234
15235 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15236 PyObject *resultobj;
15237 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15238 wxString *arg2 = 0 ;
15239 bool arg3 = (bool) false ;
15240 bool result;
15241 bool temp2 = false ;
15242 PyObject * obj0 = 0 ;
15243 PyObject * obj1 = 0 ;
15244 PyObject * obj2 = 0 ;
15245 char *kwnames[] = {
15246 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15247 };
15248
15249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15251 if (SWIG_arg_fail(1)) SWIG_fail;
15252 {
15253 arg2 = wxString_in_helper(obj1);
15254 if (arg2 == NULL) SWIG_fail;
15255 temp2 = true;
15256 }
15257 if (obj2) {
15258 {
15259 arg3 = (bool)(SWIG_As_bool(obj2));
15260 if (SWIG_arg_fail(3)) SWIG_fail;
15261 }
15262 }
15263 {
15264 PyThreadState* __tstate = wxPyBeginAllowThreads();
15265 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15266
15267 wxPyEndAllowThreads(__tstate);
15268 if (PyErr_Occurred()) SWIG_fail;
15269 }
15270 {
15271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15272 }
15273 {
15274 if (temp2)
15275 delete arg2;
15276 }
15277 return resultobj;
15278 fail:
15279 {
15280 if (temp2)
15281 delete arg2;
15282 }
15283 return NULL;
15284 }
15285
15286
15287 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15288 PyObject *resultobj;
15289 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15290 wxString *arg2 = 0 ;
15291 bool result;
15292 bool temp2 = false ;
15293 PyObject * obj0 = 0 ;
15294 PyObject * obj1 = 0 ;
15295 char *kwnames[] = {
15296 (char *) "self",(char *) "filename", NULL
15297 };
15298
15299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15301 if (SWIG_arg_fail(1)) SWIG_fail;
15302 {
15303 arg2 = wxString_in_helper(obj1);
15304 if (arg2 == NULL) SWIG_fail;
15305 temp2 = true;
15306 }
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15310
15311 wxPyEndAllowThreads(__tstate);
15312 if (PyErr_Occurred()) SWIG_fail;
15313 }
15314 {
15315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15316 }
15317 {
15318 if (temp2)
15319 delete arg2;
15320 }
15321 return resultobj;
15322 fail:
15323 {
15324 if (temp2)
15325 delete arg2;
15326 }
15327 return NULL;
15328 }
15329
15330
15331 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15332 PyObject *resultobj;
15333 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15334 PyObject *result;
15335 PyObject * obj0 = 0 ;
15336 char *kwnames[] = {
15337 (char *) "self", NULL
15338 };
15339
15340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15342 if (SWIG_arg_fail(1)) SWIG_fail;
15343 {
15344 PyThreadState* __tstate = wxPyBeginAllowThreads();
15345 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15346
15347 wxPyEndAllowThreads(__tstate);
15348 if (PyErr_Occurred()) SWIG_fail;
15349 }
15350 resultobj = result;
15351 return resultobj;
15352 fail:
15353 return NULL;
15354 }
15355
15356
15357 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15358 PyObject *resultobj;
15359 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15360 wxFileTypeInfo *arg2 = 0 ;
15361 PyObject * obj0 = 0 ;
15362 PyObject * obj1 = 0 ;
15363 char *kwnames[] = {
15364 (char *) "self",(char *) "ft", NULL
15365 };
15366
15367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15369 if (SWIG_arg_fail(1)) SWIG_fail;
15370 {
15371 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15372 if (SWIG_arg_fail(2)) SWIG_fail;
15373 if (arg2 == NULL) {
15374 SWIG_null_ref("wxFileTypeInfo");
15375 }
15376 if (SWIG_arg_fail(2)) SWIG_fail;
15377 }
15378 {
15379 PyThreadState* __tstate = wxPyBeginAllowThreads();
15380 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15381
15382 wxPyEndAllowThreads(__tstate);
15383 if (PyErr_Occurred()) SWIG_fail;
15384 }
15385 Py_INCREF(Py_None); resultobj = Py_None;
15386 return resultobj;
15387 fail:
15388 return NULL;
15389 }
15390
15391
15392 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15393 PyObject *resultobj;
15394 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15395 wxFileTypeInfo *arg2 = 0 ;
15396 wxFileType *result;
15397 PyObject * obj0 = 0 ;
15398 PyObject * obj1 = 0 ;
15399 char *kwnames[] = {
15400 (char *) "self",(char *) "ftInfo", NULL
15401 };
15402
15403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15405 if (SWIG_arg_fail(1)) SWIG_fail;
15406 {
15407 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15408 if (SWIG_arg_fail(2)) SWIG_fail;
15409 if (arg2 == NULL) {
15410 SWIG_null_ref("wxFileTypeInfo");
15411 }
15412 if (SWIG_arg_fail(2)) SWIG_fail;
15413 }
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15417
15418 wxPyEndAllowThreads(__tstate);
15419 if (PyErr_Occurred()) SWIG_fail;
15420 }
15421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15422 return resultobj;
15423 fail:
15424 return NULL;
15425 }
15426
15427
15428 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15429 PyObject *resultobj;
15430 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15431 wxFileType *arg2 = (wxFileType *) 0 ;
15432 bool result;
15433 PyObject * obj0 = 0 ;
15434 PyObject * obj1 = 0 ;
15435 char *kwnames[] = {
15436 (char *) "self",(char *) "ft", NULL
15437 };
15438
15439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15441 if (SWIG_arg_fail(1)) SWIG_fail;
15442 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15443 if (SWIG_arg_fail(2)) SWIG_fail;
15444 {
15445 PyThreadState* __tstate = wxPyBeginAllowThreads();
15446 result = (bool)(arg1)->Unassociate(arg2);
15447
15448 wxPyEndAllowThreads(__tstate);
15449 if (PyErr_Occurred()) SWIG_fail;
15450 }
15451 {
15452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15453 }
15454 return resultobj;
15455 fail:
15456 return NULL;
15457 }
15458
15459
15460 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15461 PyObject *resultobj;
15462 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15463 PyObject * obj0 = 0 ;
15464 char *kwnames[] = {
15465 (char *) "self", NULL
15466 };
15467
15468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15470 if (SWIG_arg_fail(1)) SWIG_fail;
15471 {
15472 PyThreadState* __tstate = wxPyBeginAllowThreads();
15473 delete arg1;
15474
15475 wxPyEndAllowThreads(__tstate);
15476 if (PyErr_Occurred()) SWIG_fail;
15477 }
15478 Py_INCREF(Py_None); resultobj = Py_None;
15479 return resultobj;
15480 fail:
15481 return NULL;
15482 }
15483
15484
15485 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15486 PyObject *obj;
15487 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15488 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15489 Py_INCREF(obj);
15490 return Py_BuildValue((char *)"");
15491 }
15492 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15493 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15494 return 1;
15495 }
15496
15497
15498 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15499 PyObject *pyobj;
15500
15501 {
15502 #if wxUSE_UNICODE
15503 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15504 #else
15505 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15506 #endif
15507 }
15508 return pyobj;
15509 }
15510
15511
15512 static int _wrap_ART_MENU_set(PyObject *) {
15513 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15514 return 1;
15515 }
15516
15517
15518 static PyObject *_wrap_ART_MENU_get(void) {
15519 PyObject *pyobj;
15520
15521 {
15522 #if wxUSE_UNICODE
15523 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15524 #else
15525 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15526 #endif
15527 }
15528 return pyobj;
15529 }
15530
15531
15532 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15533 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15534 return 1;
15535 }
15536
15537
15538 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15539 PyObject *pyobj;
15540
15541 {
15542 #if wxUSE_UNICODE
15543 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15544 #else
15545 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15546 #endif
15547 }
15548 return pyobj;
15549 }
15550
15551
15552 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15553 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15554 return 1;
15555 }
15556
15557
15558 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15559 PyObject *pyobj;
15560
15561 {
15562 #if wxUSE_UNICODE
15563 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15564 #else
15565 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15566 #endif
15567 }
15568 return pyobj;
15569 }
15570
15571
15572 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15573 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15574 return 1;
15575 }
15576
15577
15578 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15579 PyObject *pyobj;
15580
15581 {
15582 #if wxUSE_UNICODE
15583 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15584 #else
15585 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15586 #endif
15587 }
15588 return pyobj;
15589 }
15590
15591
15592 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15593 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15594 return 1;
15595 }
15596
15597
15598 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15599 PyObject *pyobj;
15600
15601 {
15602 #if wxUSE_UNICODE
15603 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15604 #else
15605 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15606 #endif
15607 }
15608 return pyobj;
15609 }
15610
15611
15612 static int _wrap_ART_BUTTON_set(PyObject *) {
15613 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15614 return 1;
15615 }
15616
15617
15618 static PyObject *_wrap_ART_BUTTON_get(void) {
15619 PyObject *pyobj;
15620
15621 {
15622 #if wxUSE_UNICODE
15623 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15624 #else
15625 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15626 #endif
15627 }
15628 return pyobj;
15629 }
15630
15631
15632 static int _wrap_ART_OTHER_set(PyObject *) {
15633 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15634 return 1;
15635 }
15636
15637
15638 static PyObject *_wrap_ART_OTHER_get(void) {
15639 PyObject *pyobj;
15640
15641 {
15642 #if wxUSE_UNICODE
15643 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15644 #else
15645 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15646 #endif
15647 }
15648 return pyobj;
15649 }
15650
15651
15652 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15653 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15654 return 1;
15655 }
15656
15657
15658 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15659 PyObject *pyobj;
15660
15661 {
15662 #if wxUSE_UNICODE
15663 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15664 #else
15665 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15666 #endif
15667 }
15668 return pyobj;
15669 }
15670
15671
15672 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15673 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15674 return 1;
15675 }
15676
15677
15678 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15679 PyObject *pyobj;
15680
15681 {
15682 #if wxUSE_UNICODE
15683 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15684 #else
15685 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15686 #endif
15687 }
15688 return pyobj;
15689 }
15690
15691
15692 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15693 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15694 return 1;
15695 }
15696
15697
15698 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15699 PyObject *pyobj;
15700
15701 {
15702 #if wxUSE_UNICODE
15703 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15704 #else
15705 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15706 #endif
15707 }
15708 return pyobj;
15709 }
15710
15711
15712 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15713 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15714 return 1;
15715 }
15716
15717
15718 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15719 PyObject *pyobj;
15720
15721 {
15722 #if wxUSE_UNICODE
15723 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15724 #else
15725 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15726 #endif
15727 }
15728 return pyobj;
15729 }
15730
15731
15732 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15733 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15734 return 1;
15735 }
15736
15737
15738 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15739 PyObject *pyobj;
15740
15741 {
15742 #if wxUSE_UNICODE
15743 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15744 #else
15745 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15746 #endif
15747 }
15748 return pyobj;
15749 }
15750
15751
15752 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15753 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15754 return 1;
15755 }
15756
15757
15758 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15759 PyObject *pyobj;
15760
15761 {
15762 #if wxUSE_UNICODE
15763 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15764 #else
15765 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15766 #endif
15767 }
15768 return pyobj;
15769 }
15770
15771
15772 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15773 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15774 return 1;
15775 }
15776
15777
15778 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15779 PyObject *pyobj;
15780
15781 {
15782 #if wxUSE_UNICODE
15783 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15784 #else
15785 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15786 #endif
15787 }
15788 return pyobj;
15789 }
15790
15791
15792 static int _wrap_ART_GO_BACK_set(PyObject *) {
15793 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15794 return 1;
15795 }
15796
15797
15798 static PyObject *_wrap_ART_GO_BACK_get(void) {
15799 PyObject *pyobj;
15800
15801 {
15802 #if wxUSE_UNICODE
15803 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15804 #else
15805 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15806 #endif
15807 }
15808 return pyobj;
15809 }
15810
15811
15812 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15813 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15814 return 1;
15815 }
15816
15817
15818 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15819 PyObject *pyobj;
15820
15821 {
15822 #if wxUSE_UNICODE
15823 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15824 #else
15825 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15826 #endif
15827 }
15828 return pyobj;
15829 }
15830
15831
15832 static int _wrap_ART_GO_UP_set(PyObject *) {
15833 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15834 return 1;
15835 }
15836
15837
15838 static PyObject *_wrap_ART_GO_UP_get(void) {
15839 PyObject *pyobj;
15840
15841 {
15842 #if wxUSE_UNICODE
15843 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15844 #else
15845 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15846 #endif
15847 }
15848 return pyobj;
15849 }
15850
15851
15852 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15853 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15854 return 1;
15855 }
15856
15857
15858 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15859 PyObject *pyobj;
15860
15861 {
15862 #if wxUSE_UNICODE
15863 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15864 #else
15865 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15866 #endif
15867 }
15868 return pyobj;
15869 }
15870
15871
15872 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15873 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15874 return 1;
15875 }
15876
15877
15878 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15879 PyObject *pyobj;
15880
15881 {
15882 #if wxUSE_UNICODE
15883 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15884 #else
15885 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15886 #endif
15887 }
15888 return pyobj;
15889 }
15890
15891
15892 static int _wrap_ART_GO_HOME_set(PyObject *) {
15893 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15894 return 1;
15895 }
15896
15897
15898 static PyObject *_wrap_ART_GO_HOME_get(void) {
15899 PyObject *pyobj;
15900
15901 {
15902 #if wxUSE_UNICODE
15903 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15904 #else
15905 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15906 #endif
15907 }
15908 return pyobj;
15909 }
15910
15911
15912 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15913 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15914 return 1;
15915 }
15916
15917
15918 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15919 PyObject *pyobj;
15920
15921 {
15922 #if wxUSE_UNICODE
15923 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15924 #else
15925 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15926 #endif
15927 }
15928 return pyobj;
15929 }
15930
15931
15932 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15933 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15934 return 1;
15935 }
15936
15937
15938 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15939 PyObject *pyobj;
15940
15941 {
15942 #if wxUSE_UNICODE
15943 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15944 #else
15945 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15946 #endif
15947 }
15948 return pyobj;
15949 }
15950
15951
15952 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15953 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15954 return 1;
15955 }
15956
15957
15958 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15959 PyObject *pyobj;
15960
15961 {
15962 #if wxUSE_UNICODE
15963 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15964 #else
15965 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15966 #endif
15967 }
15968 return pyobj;
15969 }
15970
15971
15972 static int _wrap_ART_PRINT_set(PyObject *) {
15973 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15974 return 1;
15975 }
15976
15977
15978 static PyObject *_wrap_ART_PRINT_get(void) {
15979 PyObject *pyobj;
15980
15981 {
15982 #if wxUSE_UNICODE
15983 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15984 #else
15985 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15986 #endif
15987 }
15988 return pyobj;
15989 }
15990
15991
15992 static int _wrap_ART_HELP_set(PyObject *) {
15993 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15994 return 1;
15995 }
15996
15997
15998 static PyObject *_wrap_ART_HELP_get(void) {
15999 PyObject *pyobj;
16000
16001 {
16002 #if wxUSE_UNICODE
16003 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16004 #else
16005 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16006 #endif
16007 }
16008 return pyobj;
16009 }
16010
16011
16012 static int _wrap_ART_TIP_set(PyObject *) {
16013 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16014 return 1;
16015 }
16016
16017
16018 static PyObject *_wrap_ART_TIP_get(void) {
16019 PyObject *pyobj;
16020
16021 {
16022 #if wxUSE_UNICODE
16023 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16024 #else
16025 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16026 #endif
16027 }
16028 return pyobj;
16029 }
16030
16031
16032 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16033 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16034 return 1;
16035 }
16036
16037
16038 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16039 PyObject *pyobj;
16040
16041 {
16042 #if wxUSE_UNICODE
16043 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16044 #else
16045 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16046 #endif
16047 }
16048 return pyobj;
16049 }
16050
16051
16052 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16053 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16054 return 1;
16055 }
16056
16057
16058 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16059 PyObject *pyobj;
16060
16061 {
16062 #if wxUSE_UNICODE
16063 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16064 #else
16065 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16066 #endif
16067 }
16068 return pyobj;
16069 }
16070
16071
16072 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16073 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16074 return 1;
16075 }
16076
16077
16078 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16079 PyObject *pyobj;
16080
16081 {
16082 #if wxUSE_UNICODE
16083 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16084 #else
16085 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16086 #endif
16087 }
16088 return pyobj;
16089 }
16090
16091
16092 static int _wrap_ART_HARDDISK_set(PyObject *) {
16093 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16094 return 1;
16095 }
16096
16097
16098 static PyObject *_wrap_ART_HARDDISK_get(void) {
16099 PyObject *pyobj;
16100
16101 {
16102 #if wxUSE_UNICODE
16103 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16104 #else
16105 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16106 #endif
16107 }
16108 return pyobj;
16109 }
16110
16111
16112 static int _wrap_ART_FLOPPY_set(PyObject *) {
16113 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16114 return 1;
16115 }
16116
16117
16118 static PyObject *_wrap_ART_FLOPPY_get(void) {
16119 PyObject *pyobj;
16120
16121 {
16122 #if wxUSE_UNICODE
16123 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16124 #else
16125 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16126 #endif
16127 }
16128 return pyobj;
16129 }
16130
16131
16132 static int _wrap_ART_CDROM_set(PyObject *) {
16133 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16134 return 1;
16135 }
16136
16137
16138 static PyObject *_wrap_ART_CDROM_get(void) {
16139 PyObject *pyobj;
16140
16141 {
16142 #if wxUSE_UNICODE
16143 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16144 #else
16145 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16146 #endif
16147 }
16148 return pyobj;
16149 }
16150
16151
16152 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16153 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16154 return 1;
16155 }
16156
16157
16158 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16159 PyObject *pyobj;
16160
16161 {
16162 #if wxUSE_UNICODE
16163 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16164 #else
16165 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16166 #endif
16167 }
16168 return pyobj;
16169 }
16170
16171
16172 static int _wrap_ART_FOLDER_set(PyObject *) {
16173 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16174 return 1;
16175 }
16176
16177
16178 static PyObject *_wrap_ART_FOLDER_get(void) {
16179 PyObject *pyobj;
16180
16181 {
16182 #if wxUSE_UNICODE
16183 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16184 #else
16185 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16186 #endif
16187 }
16188 return pyobj;
16189 }
16190
16191
16192 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16193 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16194 return 1;
16195 }
16196
16197
16198 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16199 PyObject *pyobj;
16200
16201 {
16202 #if wxUSE_UNICODE
16203 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16204 #else
16205 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16206 #endif
16207 }
16208 return pyobj;
16209 }
16210
16211
16212 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16213 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16214 return 1;
16215 }
16216
16217
16218 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16219 PyObject *pyobj;
16220
16221 {
16222 #if wxUSE_UNICODE
16223 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16224 #else
16225 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16226 #endif
16227 }
16228 return pyobj;
16229 }
16230
16231
16232 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16233 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16234 return 1;
16235 }
16236
16237
16238 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16239 PyObject *pyobj;
16240
16241 {
16242 #if wxUSE_UNICODE
16243 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16244 #else
16245 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16246 #endif
16247 }
16248 return pyobj;
16249 }
16250
16251
16252 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16253 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16254 return 1;
16255 }
16256
16257
16258 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16259 PyObject *pyobj;
16260
16261 {
16262 #if wxUSE_UNICODE
16263 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16264 #else
16265 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16266 #endif
16267 }
16268 return pyobj;
16269 }
16270
16271
16272 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16273 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16274 return 1;
16275 }
16276
16277
16278 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16279 PyObject *pyobj;
16280
16281 {
16282 #if wxUSE_UNICODE
16283 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16284 #else
16285 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16286 #endif
16287 }
16288 return pyobj;
16289 }
16290
16291
16292 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16293 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16294 return 1;
16295 }
16296
16297
16298 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16299 PyObject *pyobj;
16300
16301 {
16302 #if wxUSE_UNICODE
16303 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16304 #else
16305 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16306 #endif
16307 }
16308 return pyobj;
16309 }
16310
16311
16312 static int _wrap_ART_ERROR_set(PyObject *) {
16313 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16314 return 1;
16315 }
16316
16317
16318 static PyObject *_wrap_ART_ERROR_get(void) {
16319 PyObject *pyobj;
16320
16321 {
16322 #if wxUSE_UNICODE
16323 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16324 #else
16325 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16326 #endif
16327 }
16328 return pyobj;
16329 }
16330
16331
16332 static int _wrap_ART_QUESTION_set(PyObject *) {
16333 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16334 return 1;
16335 }
16336
16337
16338 static PyObject *_wrap_ART_QUESTION_get(void) {
16339 PyObject *pyobj;
16340
16341 {
16342 #if wxUSE_UNICODE
16343 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16344 #else
16345 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16346 #endif
16347 }
16348 return pyobj;
16349 }
16350
16351
16352 static int _wrap_ART_WARNING_set(PyObject *) {
16353 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16354 return 1;
16355 }
16356
16357
16358 static PyObject *_wrap_ART_WARNING_get(void) {
16359 PyObject *pyobj;
16360
16361 {
16362 #if wxUSE_UNICODE
16363 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16364 #else
16365 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16366 #endif
16367 }
16368 return pyobj;
16369 }
16370
16371
16372 static int _wrap_ART_INFORMATION_set(PyObject *) {
16373 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16374 return 1;
16375 }
16376
16377
16378 static PyObject *_wrap_ART_INFORMATION_get(void) {
16379 PyObject *pyobj;
16380
16381 {
16382 #if wxUSE_UNICODE
16383 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16384 #else
16385 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16386 #endif
16387 }
16388 return pyobj;
16389 }
16390
16391
16392 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16393 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16394 return 1;
16395 }
16396
16397
16398 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16399 PyObject *pyobj;
16400
16401 {
16402 #if wxUSE_UNICODE
16403 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16404 #else
16405 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16406 #endif
16407 }
16408 return pyobj;
16409 }
16410
16411
16412 static int _wrap_ART_COPY_set(PyObject *) {
16413 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16414 return 1;
16415 }
16416
16417
16418 static PyObject *_wrap_ART_COPY_get(void) {
16419 PyObject *pyobj;
16420
16421 {
16422 #if wxUSE_UNICODE
16423 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16424 #else
16425 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16426 #endif
16427 }
16428 return pyobj;
16429 }
16430
16431
16432 static int _wrap_ART_CUT_set(PyObject *) {
16433 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16434 return 1;
16435 }
16436
16437
16438 static PyObject *_wrap_ART_CUT_get(void) {
16439 PyObject *pyobj;
16440
16441 {
16442 #if wxUSE_UNICODE
16443 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16444 #else
16445 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16446 #endif
16447 }
16448 return pyobj;
16449 }
16450
16451
16452 static int _wrap_ART_PASTE_set(PyObject *) {
16453 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16454 return 1;
16455 }
16456
16457
16458 static PyObject *_wrap_ART_PASTE_get(void) {
16459 PyObject *pyobj;
16460
16461 {
16462 #if wxUSE_UNICODE
16463 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16464 #else
16465 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16466 #endif
16467 }
16468 return pyobj;
16469 }
16470
16471
16472 static int _wrap_ART_DELETE_set(PyObject *) {
16473 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16474 return 1;
16475 }
16476
16477
16478 static PyObject *_wrap_ART_DELETE_get(void) {
16479 PyObject *pyobj;
16480
16481 {
16482 #if wxUSE_UNICODE
16483 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16484 #else
16485 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16486 #endif
16487 }
16488 return pyobj;
16489 }
16490
16491
16492 static int _wrap_ART_NEW_set(PyObject *) {
16493 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW is read-only.");
16494 return 1;
16495 }
16496
16497
16498 static PyObject *_wrap_ART_NEW_get(void) {
16499 PyObject *pyobj;
16500
16501 {
16502 #if wxUSE_UNICODE
16503 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
16504 #else
16505 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
16506 #endif
16507 }
16508 return pyobj;
16509 }
16510
16511
16512 static int _wrap_ART_UNDO_set(PyObject *) {
16513 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16514 return 1;
16515 }
16516
16517
16518 static PyObject *_wrap_ART_UNDO_get(void) {
16519 PyObject *pyobj;
16520
16521 {
16522 #if wxUSE_UNICODE
16523 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16524 #else
16525 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16526 #endif
16527 }
16528 return pyobj;
16529 }
16530
16531
16532 static int _wrap_ART_REDO_set(PyObject *) {
16533 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16534 return 1;
16535 }
16536
16537
16538 static PyObject *_wrap_ART_REDO_get(void) {
16539 PyObject *pyobj;
16540
16541 {
16542 #if wxUSE_UNICODE
16543 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16544 #else
16545 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16546 #endif
16547 }
16548 return pyobj;
16549 }
16550
16551
16552 static int _wrap_ART_QUIT_set(PyObject *) {
16553 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16554 return 1;
16555 }
16556
16557
16558 static PyObject *_wrap_ART_QUIT_get(void) {
16559 PyObject *pyobj;
16560
16561 {
16562 #if wxUSE_UNICODE
16563 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16564 #else
16565 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16566 #endif
16567 }
16568 return pyobj;
16569 }
16570
16571
16572 static int _wrap_ART_FIND_set(PyObject *) {
16573 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16574 return 1;
16575 }
16576
16577
16578 static PyObject *_wrap_ART_FIND_get(void) {
16579 PyObject *pyobj;
16580
16581 {
16582 #if wxUSE_UNICODE
16583 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16584 #else
16585 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16586 #endif
16587 }
16588 return pyobj;
16589 }
16590
16591
16592 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16593 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16594 return 1;
16595 }
16596
16597
16598 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16599 PyObject *pyobj;
16600
16601 {
16602 #if wxUSE_UNICODE
16603 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16604 #else
16605 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16606 #endif
16607 }
16608 return pyobj;
16609 }
16610
16611
16612 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16613 PyObject *resultobj;
16614 wxPyArtProvider *result;
16615 char *kwnames[] = {
16616 NULL
16617 };
16618
16619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16620 {
16621 if (!wxPyCheckForApp()) SWIG_fail;
16622 PyThreadState* __tstate = wxPyBeginAllowThreads();
16623 result = (wxPyArtProvider *)new wxPyArtProvider();
16624
16625 wxPyEndAllowThreads(__tstate);
16626 if (PyErr_Occurred()) SWIG_fail;
16627 }
16628 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16629 return resultobj;
16630 fail:
16631 return NULL;
16632 }
16633
16634
16635 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16636 PyObject *resultobj;
16637 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16638 PyObject *arg2 = (PyObject *) 0 ;
16639 PyObject *arg3 = (PyObject *) 0 ;
16640 PyObject * obj0 = 0 ;
16641 PyObject * obj1 = 0 ;
16642 PyObject * obj2 = 0 ;
16643 char *kwnames[] = {
16644 (char *) "self",(char *) "self",(char *) "_class", NULL
16645 };
16646
16647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16649 if (SWIG_arg_fail(1)) SWIG_fail;
16650 arg2 = obj1;
16651 arg3 = obj2;
16652 {
16653 PyThreadState* __tstate = wxPyBeginAllowThreads();
16654 (arg1)->_setCallbackInfo(arg2,arg3);
16655
16656 wxPyEndAllowThreads(__tstate);
16657 if (PyErr_Occurred()) SWIG_fail;
16658 }
16659 Py_INCREF(Py_None); resultobj = Py_None;
16660 return resultobj;
16661 fail:
16662 return NULL;
16663 }
16664
16665
16666 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16667 PyObject *resultobj;
16668 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16669 PyObject * obj0 = 0 ;
16670 char *kwnames[] = {
16671 (char *) "provider", NULL
16672 };
16673
16674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16676 if (SWIG_arg_fail(1)) SWIG_fail;
16677 {
16678 PyThreadState* __tstate = wxPyBeginAllowThreads();
16679 wxPyArtProvider::PushProvider(arg1);
16680
16681 wxPyEndAllowThreads(__tstate);
16682 if (PyErr_Occurred()) SWIG_fail;
16683 }
16684 Py_INCREF(Py_None); resultobj = Py_None;
16685 return resultobj;
16686 fail:
16687 return NULL;
16688 }
16689
16690
16691 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16692 PyObject *resultobj;
16693 bool result;
16694 char *kwnames[] = {
16695 NULL
16696 };
16697
16698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16699 {
16700 PyThreadState* __tstate = wxPyBeginAllowThreads();
16701 result = (bool)wxPyArtProvider::PopProvider();
16702
16703 wxPyEndAllowThreads(__tstate);
16704 if (PyErr_Occurred()) SWIG_fail;
16705 }
16706 {
16707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16708 }
16709 return resultobj;
16710 fail:
16711 return NULL;
16712 }
16713
16714
16715 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16716 PyObject *resultobj;
16717 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16718 bool result;
16719 PyObject * obj0 = 0 ;
16720 char *kwnames[] = {
16721 (char *) "provider", NULL
16722 };
16723
16724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16726 if (SWIG_arg_fail(1)) SWIG_fail;
16727 {
16728 PyThreadState* __tstate = wxPyBeginAllowThreads();
16729 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16730
16731 wxPyEndAllowThreads(__tstate);
16732 if (PyErr_Occurred()) SWIG_fail;
16733 }
16734 {
16735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16736 }
16737 return resultobj;
16738 fail:
16739 return NULL;
16740 }
16741
16742
16743 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16744 PyObject *resultobj;
16745 wxString *arg1 = 0 ;
16746 wxString const &arg2_defvalue = wxPyART_OTHER ;
16747 wxString *arg2 = (wxString *) &arg2_defvalue ;
16748 wxSize const &arg3_defvalue = wxDefaultSize ;
16749 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16750 wxBitmap result;
16751 bool temp1 = false ;
16752 bool temp2 = false ;
16753 wxSize temp3 ;
16754 PyObject * obj0 = 0 ;
16755 PyObject * obj1 = 0 ;
16756 PyObject * obj2 = 0 ;
16757 char *kwnames[] = {
16758 (char *) "id",(char *) "client",(char *) "size", NULL
16759 };
16760
16761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16762 {
16763 arg1 = wxString_in_helper(obj0);
16764 if (arg1 == NULL) SWIG_fail;
16765 temp1 = true;
16766 }
16767 if (obj1) {
16768 {
16769 arg2 = wxString_in_helper(obj1);
16770 if (arg2 == NULL) SWIG_fail;
16771 temp2 = true;
16772 }
16773 }
16774 if (obj2) {
16775 {
16776 arg3 = &temp3;
16777 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16778 }
16779 }
16780 {
16781 if (!wxPyCheckForApp()) SWIG_fail;
16782 PyThreadState* __tstate = wxPyBeginAllowThreads();
16783 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16784
16785 wxPyEndAllowThreads(__tstate);
16786 if (PyErr_Occurred()) SWIG_fail;
16787 }
16788 {
16789 wxBitmap * resultptr;
16790 resultptr = new wxBitmap((wxBitmap &)(result));
16791 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16792 }
16793 {
16794 if (temp1)
16795 delete arg1;
16796 }
16797 {
16798 if (temp2)
16799 delete arg2;
16800 }
16801 return resultobj;
16802 fail:
16803 {
16804 if (temp1)
16805 delete arg1;
16806 }
16807 {
16808 if (temp2)
16809 delete arg2;
16810 }
16811 return NULL;
16812 }
16813
16814
16815 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16816 PyObject *resultobj;
16817 wxString *arg1 = 0 ;
16818 wxString const &arg2_defvalue = wxPyART_OTHER ;
16819 wxString *arg2 = (wxString *) &arg2_defvalue ;
16820 wxSize const &arg3_defvalue = wxDefaultSize ;
16821 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16822 wxIcon result;
16823 bool temp1 = false ;
16824 bool temp2 = false ;
16825 wxSize temp3 ;
16826 PyObject * obj0 = 0 ;
16827 PyObject * obj1 = 0 ;
16828 PyObject * obj2 = 0 ;
16829 char *kwnames[] = {
16830 (char *) "id",(char *) "client",(char *) "size", NULL
16831 };
16832
16833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16834 {
16835 arg1 = wxString_in_helper(obj0);
16836 if (arg1 == NULL) SWIG_fail;
16837 temp1 = true;
16838 }
16839 if (obj1) {
16840 {
16841 arg2 = wxString_in_helper(obj1);
16842 if (arg2 == NULL) SWIG_fail;
16843 temp2 = true;
16844 }
16845 }
16846 if (obj2) {
16847 {
16848 arg3 = &temp3;
16849 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16850 }
16851 }
16852 {
16853 if (!wxPyCheckForApp()) SWIG_fail;
16854 PyThreadState* __tstate = wxPyBeginAllowThreads();
16855 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16856
16857 wxPyEndAllowThreads(__tstate);
16858 if (PyErr_Occurred()) SWIG_fail;
16859 }
16860 {
16861 wxIcon * resultptr;
16862 resultptr = new wxIcon((wxIcon &)(result));
16863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16864 }
16865 {
16866 if (temp1)
16867 delete arg1;
16868 }
16869 {
16870 if (temp2)
16871 delete arg2;
16872 }
16873 return resultobj;
16874 fail:
16875 {
16876 if (temp1)
16877 delete arg1;
16878 }
16879 {
16880 if (temp2)
16881 delete arg2;
16882 }
16883 return NULL;
16884 }
16885
16886
16887 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16888 PyObject *resultobj;
16889 wxString *arg1 = 0 ;
16890 bool arg2 = (bool) false ;
16891 wxSize result;
16892 bool temp1 = false ;
16893 PyObject * obj0 = 0 ;
16894 PyObject * obj1 = 0 ;
16895 char *kwnames[] = {
16896 (char *) "client",(char *) "platform_dependent", NULL
16897 };
16898
16899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16900 {
16901 arg1 = wxString_in_helper(obj0);
16902 if (arg1 == NULL) SWIG_fail;
16903 temp1 = true;
16904 }
16905 if (obj1) {
16906 {
16907 arg2 = (bool)(SWIG_As_bool(obj1));
16908 if (SWIG_arg_fail(2)) SWIG_fail;
16909 }
16910 }
16911 {
16912 PyThreadState* __tstate = wxPyBeginAllowThreads();
16913 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16914
16915 wxPyEndAllowThreads(__tstate);
16916 if (PyErr_Occurred()) SWIG_fail;
16917 }
16918 {
16919 wxSize * resultptr;
16920 resultptr = new wxSize((wxSize &)(result));
16921 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16922 }
16923 {
16924 if (temp1)
16925 delete arg1;
16926 }
16927 return resultobj;
16928 fail:
16929 {
16930 if (temp1)
16931 delete arg1;
16932 }
16933 return NULL;
16934 }
16935
16936
16937 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16938 PyObject *resultobj;
16939 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16940 PyObject * obj0 = 0 ;
16941 char *kwnames[] = {
16942 (char *) "self", NULL
16943 };
16944
16945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16947 if (SWIG_arg_fail(1)) SWIG_fail;
16948 {
16949 PyThreadState* __tstate = wxPyBeginAllowThreads();
16950 wxPyArtProvider_Destroy(arg1);
16951
16952 wxPyEndAllowThreads(__tstate);
16953 if (PyErr_Occurred()) SWIG_fail;
16954 }
16955 Py_INCREF(Py_None); resultobj = Py_None;
16956 return resultobj;
16957 fail:
16958 return NULL;
16959 }
16960
16961
16962 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16963 PyObject *obj;
16964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16965 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16966 Py_INCREF(obj);
16967 return Py_BuildValue((char *)"");
16968 }
16969 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16970 PyObject *resultobj;
16971 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16972 PyObject * obj0 = 0 ;
16973 char *kwnames[] = {
16974 (char *) "self", NULL
16975 };
16976
16977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16979 if (SWIG_arg_fail(1)) SWIG_fail;
16980 {
16981 PyThreadState* __tstate = wxPyBeginAllowThreads();
16982 delete arg1;
16983
16984 wxPyEndAllowThreads(__tstate);
16985 if (PyErr_Occurred()) SWIG_fail;
16986 }
16987 Py_INCREF(Py_None); resultobj = Py_None;
16988 return resultobj;
16989 fail:
16990 return NULL;
16991 }
16992
16993
16994 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16995 PyObject *resultobj;
16996 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16997 wxConfigBase *result;
16998 PyObject * obj0 = 0 ;
16999 char *kwnames[] = {
17000 (char *) "config", NULL
17001 };
17002
17003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
17004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
17005 if (SWIG_arg_fail(1)) SWIG_fail;
17006 {
17007 PyThreadState* __tstate = wxPyBeginAllowThreads();
17008 result = (wxConfigBase *)wxConfigBase::Set(arg1);
17009
17010 wxPyEndAllowThreads(__tstate);
17011 if (PyErr_Occurred()) SWIG_fail;
17012 }
17013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17014 return resultobj;
17015 fail:
17016 return NULL;
17017 }
17018
17019
17020 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
17021 PyObject *resultobj;
17022 bool arg1 = (bool) true ;
17023 wxConfigBase *result;
17024 PyObject * obj0 = 0 ;
17025 char *kwnames[] = {
17026 (char *) "createOnDemand", NULL
17027 };
17028
17029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
17030 if (obj0) {
17031 {
17032 arg1 = (bool)(SWIG_As_bool(obj0));
17033 if (SWIG_arg_fail(1)) SWIG_fail;
17034 }
17035 }
17036 {
17037 PyThreadState* __tstate = wxPyBeginAllowThreads();
17038 result = (wxConfigBase *)wxConfigBase::Get(arg1);
17039
17040 wxPyEndAllowThreads(__tstate);
17041 if (PyErr_Occurred()) SWIG_fail;
17042 }
17043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17044 return resultobj;
17045 fail:
17046 return NULL;
17047 }
17048
17049
17050 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17051 PyObject *resultobj;
17052 wxConfigBase *result;
17053 char *kwnames[] = {
17054 NULL
17055 };
17056
17057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17058 {
17059 PyThreadState* __tstate = wxPyBeginAllowThreads();
17060 result = (wxConfigBase *)wxConfigBase::Create();
17061
17062 wxPyEndAllowThreads(__tstate);
17063 if (PyErr_Occurred()) SWIG_fail;
17064 }
17065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17066 return resultobj;
17067 fail:
17068 return NULL;
17069 }
17070
17071
17072 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17073 PyObject *resultobj;
17074 char *kwnames[] = {
17075 NULL
17076 };
17077
17078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17079 {
17080 PyThreadState* __tstate = wxPyBeginAllowThreads();
17081 wxConfigBase::DontCreateOnDemand();
17082
17083 wxPyEndAllowThreads(__tstate);
17084 if (PyErr_Occurred()) SWIG_fail;
17085 }
17086 Py_INCREF(Py_None); resultobj = Py_None;
17087 return resultobj;
17088 fail:
17089 return NULL;
17090 }
17091
17092
17093 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17094 PyObject *resultobj;
17095 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17096 wxString *arg2 = 0 ;
17097 bool temp2 = false ;
17098 PyObject * obj0 = 0 ;
17099 PyObject * obj1 = 0 ;
17100 char *kwnames[] = {
17101 (char *) "self",(char *) "path", NULL
17102 };
17103
17104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17106 if (SWIG_arg_fail(1)) SWIG_fail;
17107 {
17108 arg2 = wxString_in_helper(obj1);
17109 if (arg2 == NULL) SWIG_fail;
17110 temp2 = true;
17111 }
17112 {
17113 PyThreadState* __tstate = wxPyBeginAllowThreads();
17114 (arg1)->SetPath((wxString const &)*arg2);
17115
17116 wxPyEndAllowThreads(__tstate);
17117 if (PyErr_Occurred()) SWIG_fail;
17118 }
17119 Py_INCREF(Py_None); resultobj = Py_None;
17120 {
17121 if (temp2)
17122 delete arg2;
17123 }
17124 return resultobj;
17125 fail:
17126 {
17127 if (temp2)
17128 delete arg2;
17129 }
17130 return NULL;
17131 }
17132
17133
17134 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17135 PyObject *resultobj;
17136 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17137 wxString *result;
17138 PyObject * obj0 = 0 ;
17139 char *kwnames[] = {
17140 (char *) "self", NULL
17141 };
17142
17143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17145 if (SWIG_arg_fail(1)) SWIG_fail;
17146 {
17147 PyThreadState* __tstate = wxPyBeginAllowThreads();
17148 {
17149 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17150 result = (wxString *) &_result_ref;
17151 }
17152
17153 wxPyEndAllowThreads(__tstate);
17154 if (PyErr_Occurred()) SWIG_fail;
17155 }
17156 {
17157 #if wxUSE_UNICODE
17158 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17159 #else
17160 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17161 #endif
17162 }
17163 return resultobj;
17164 fail:
17165 return NULL;
17166 }
17167
17168
17169 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17170 PyObject *resultobj;
17171 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17172 PyObject *result;
17173 PyObject * obj0 = 0 ;
17174 char *kwnames[] = {
17175 (char *) "self", NULL
17176 };
17177
17178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17180 if (SWIG_arg_fail(1)) SWIG_fail;
17181 {
17182 PyThreadState* __tstate = wxPyBeginAllowThreads();
17183 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17184
17185 wxPyEndAllowThreads(__tstate);
17186 if (PyErr_Occurred()) SWIG_fail;
17187 }
17188 resultobj = result;
17189 return resultobj;
17190 fail:
17191 return NULL;
17192 }
17193
17194
17195 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17196 PyObject *resultobj;
17197 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17198 long arg2 ;
17199 PyObject *result;
17200 PyObject * obj0 = 0 ;
17201 PyObject * obj1 = 0 ;
17202 char *kwnames[] = {
17203 (char *) "self",(char *) "index", NULL
17204 };
17205
17206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17208 if (SWIG_arg_fail(1)) SWIG_fail;
17209 {
17210 arg2 = (long)(SWIG_As_long(obj1));
17211 if (SWIG_arg_fail(2)) SWIG_fail;
17212 }
17213 {
17214 PyThreadState* __tstate = wxPyBeginAllowThreads();
17215 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17216
17217 wxPyEndAllowThreads(__tstate);
17218 if (PyErr_Occurred()) SWIG_fail;
17219 }
17220 resultobj = result;
17221 return resultobj;
17222 fail:
17223 return NULL;
17224 }
17225
17226
17227 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17228 PyObject *resultobj;
17229 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17230 PyObject *result;
17231 PyObject * obj0 = 0 ;
17232 char *kwnames[] = {
17233 (char *) "self", NULL
17234 };
17235
17236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17238 if (SWIG_arg_fail(1)) SWIG_fail;
17239 {
17240 PyThreadState* __tstate = wxPyBeginAllowThreads();
17241 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17242
17243 wxPyEndAllowThreads(__tstate);
17244 if (PyErr_Occurred()) SWIG_fail;
17245 }
17246 resultobj = result;
17247 return resultobj;
17248 fail:
17249 return NULL;
17250 }
17251
17252
17253 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17254 PyObject *resultobj;
17255 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17256 long arg2 ;
17257 PyObject *result;
17258 PyObject * obj0 = 0 ;
17259 PyObject * obj1 = 0 ;
17260 char *kwnames[] = {
17261 (char *) "self",(char *) "index", NULL
17262 };
17263
17264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17266 if (SWIG_arg_fail(1)) SWIG_fail;
17267 {
17268 arg2 = (long)(SWIG_As_long(obj1));
17269 if (SWIG_arg_fail(2)) SWIG_fail;
17270 }
17271 {
17272 PyThreadState* __tstate = wxPyBeginAllowThreads();
17273 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17274
17275 wxPyEndAllowThreads(__tstate);
17276 if (PyErr_Occurred()) SWIG_fail;
17277 }
17278 resultobj = result;
17279 return resultobj;
17280 fail:
17281 return NULL;
17282 }
17283
17284
17285 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17286 PyObject *resultobj;
17287 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17288 bool arg2 = (bool) false ;
17289 size_t result;
17290 PyObject * obj0 = 0 ;
17291 PyObject * obj1 = 0 ;
17292 char *kwnames[] = {
17293 (char *) "self",(char *) "recursive", NULL
17294 };
17295
17296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17298 if (SWIG_arg_fail(1)) SWIG_fail;
17299 if (obj1) {
17300 {
17301 arg2 = (bool)(SWIG_As_bool(obj1));
17302 if (SWIG_arg_fail(2)) SWIG_fail;
17303 }
17304 }
17305 {
17306 PyThreadState* __tstate = wxPyBeginAllowThreads();
17307 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17308
17309 wxPyEndAllowThreads(__tstate);
17310 if (PyErr_Occurred()) SWIG_fail;
17311 }
17312 {
17313 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17314 }
17315 return resultobj;
17316 fail:
17317 return NULL;
17318 }
17319
17320
17321 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17322 PyObject *resultobj;
17323 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17324 bool arg2 = (bool) false ;
17325 size_t result;
17326 PyObject * obj0 = 0 ;
17327 PyObject * obj1 = 0 ;
17328 char *kwnames[] = {
17329 (char *) "self",(char *) "recursive", NULL
17330 };
17331
17332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17334 if (SWIG_arg_fail(1)) SWIG_fail;
17335 if (obj1) {
17336 {
17337 arg2 = (bool)(SWIG_As_bool(obj1));
17338 if (SWIG_arg_fail(2)) SWIG_fail;
17339 }
17340 }
17341 {
17342 PyThreadState* __tstate = wxPyBeginAllowThreads();
17343 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17344
17345 wxPyEndAllowThreads(__tstate);
17346 if (PyErr_Occurred()) SWIG_fail;
17347 }
17348 {
17349 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17350 }
17351 return resultobj;
17352 fail:
17353 return NULL;
17354 }
17355
17356
17357 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17358 PyObject *resultobj;
17359 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17360 wxString *arg2 = 0 ;
17361 bool result;
17362 bool temp2 = false ;
17363 PyObject * obj0 = 0 ;
17364 PyObject * obj1 = 0 ;
17365 char *kwnames[] = {
17366 (char *) "self",(char *) "name", NULL
17367 };
17368
17369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17371 if (SWIG_arg_fail(1)) SWIG_fail;
17372 {
17373 arg2 = wxString_in_helper(obj1);
17374 if (arg2 == NULL) SWIG_fail;
17375 temp2 = true;
17376 }
17377 {
17378 PyThreadState* __tstate = wxPyBeginAllowThreads();
17379 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17380
17381 wxPyEndAllowThreads(__tstate);
17382 if (PyErr_Occurred()) SWIG_fail;
17383 }
17384 {
17385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17386 }
17387 {
17388 if (temp2)
17389 delete arg2;
17390 }
17391 return resultobj;
17392 fail:
17393 {
17394 if (temp2)
17395 delete arg2;
17396 }
17397 return NULL;
17398 }
17399
17400
17401 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj;
17403 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17404 wxString *arg2 = 0 ;
17405 bool result;
17406 bool temp2 = false ;
17407 PyObject * obj0 = 0 ;
17408 PyObject * obj1 = 0 ;
17409 char *kwnames[] = {
17410 (char *) "self",(char *) "name", NULL
17411 };
17412
17413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17415 if (SWIG_arg_fail(1)) SWIG_fail;
17416 {
17417 arg2 = wxString_in_helper(obj1);
17418 if (arg2 == NULL) SWIG_fail;
17419 temp2 = true;
17420 }
17421 {
17422 PyThreadState* __tstate = wxPyBeginAllowThreads();
17423 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17424
17425 wxPyEndAllowThreads(__tstate);
17426 if (PyErr_Occurred()) SWIG_fail;
17427 }
17428 {
17429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17430 }
17431 {
17432 if (temp2)
17433 delete arg2;
17434 }
17435 return resultobj;
17436 fail:
17437 {
17438 if (temp2)
17439 delete arg2;
17440 }
17441 return NULL;
17442 }
17443
17444
17445 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17446 PyObject *resultobj;
17447 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17448 wxString *arg2 = 0 ;
17449 bool result;
17450 bool temp2 = false ;
17451 PyObject * obj0 = 0 ;
17452 PyObject * obj1 = 0 ;
17453 char *kwnames[] = {
17454 (char *) "self",(char *) "name", NULL
17455 };
17456
17457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
17467 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17468
17469 wxPyEndAllowThreads(__tstate);
17470 if (PyErr_Occurred()) SWIG_fail;
17471 }
17472 {
17473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17474 }
17475 {
17476 if (temp2)
17477 delete arg2;
17478 }
17479 return resultobj;
17480 fail:
17481 {
17482 if (temp2)
17483 delete arg2;
17484 }
17485 return NULL;
17486 }
17487
17488
17489 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17490 PyObject *resultobj;
17491 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17492 wxString *arg2 = 0 ;
17493 wxConfigBase::EntryType result;
17494 bool temp2 = false ;
17495 PyObject * obj0 = 0 ;
17496 PyObject * obj1 = 0 ;
17497 char *kwnames[] = {
17498 (char *) "self",(char *) "name", NULL
17499 };
17500
17501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17503 if (SWIG_arg_fail(1)) SWIG_fail;
17504 {
17505 arg2 = wxString_in_helper(obj1);
17506 if (arg2 == NULL) SWIG_fail;
17507 temp2 = true;
17508 }
17509 {
17510 PyThreadState* __tstate = wxPyBeginAllowThreads();
17511 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17512
17513 wxPyEndAllowThreads(__tstate);
17514 if (PyErr_Occurred()) SWIG_fail;
17515 }
17516 resultobj = SWIG_From_int((result));
17517 {
17518 if (temp2)
17519 delete arg2;
17520 }
17521 return resultobj;
17522 fail:
17523 {
17524 if (temp2)
17525 delete arg2;
17526 }
17527 return NULL;
17528 }
17529
17530
17531 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17532 PyObject *resultobj;
17533 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17534 wxString *arg2 = 0 ;
17535 wxString const &arg3_defvalue = wxPyEmptyString ;
17536 wxString *arg3 = (wxString *) &arg3_defvalue ;
17537 wxString result;
17538 bool temp2 = false ;
17539 bool temp3 = false ;
17540 PyObject * obj0 = 0 ;
17541 PyObject * obj1 = 0 ;
17542 PyObject * obj2 = 0 ;
17543 char *kwnames[] = {
17544 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17545 };
17546
17547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17549 if (SWIG_arg_fail(1)) SWIG_fail;
17550 {
17551 arg2 = wxString_in_helper(obj1);
17552 if (arg2 == NULL) SWIG_fail;
17553 temp2 = true;
17554 }
17555 if (obj2) {
17556 {
17557 arg3 = wxString_in_helper(obj2);
17558 if (arg3 == NULL) SWIG_fail;
17559 temp3 = true;
17560 }
17561 }
17562 {
17563 PyThreadState* __tstate = wxPyBeginAllowThreads();
17564 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17565
17566 wxPyEndAllowThreads(__tstate);
17567 if (PyErr_Occurred()) SWIG_fail;
17568 }
17569 {
17570 #if wxUSE_UNICODE
17571 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17572 #else
17573 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17574 #endif
17575 }
17576 {
17577 if (temp2)
17578 delete arg2;
17579 }
17580 {
17581 if (temp3)
17582 delete arg3;
17583 }
17584 return resultobj;
17585 fail:
17586 {
17587 if (temp2)
17588 delete arg2;
17589 }
17590 {
17591 if (temp3)
17592 delete arg3;
17593 }
17594 return NULL;
17595 }
17596
17597
17598 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17599 PyObject *resultobj;
17600 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17601 wxString *arg2 = 0 ;
17602 long arg3 = (long) 0 ;
17603 long result;
17604 bool temp2 = false ;
17605 PyObject * obj0 = 0 ;
17606 PyObject * obj1 = 0 ;
17607 PyObject * obj2 = 0 ;
17608 char *kwnames[] = {
17609 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17610 };
17611
17612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17614 if (SWIG_arg_fail(1)) SWIG_fail;
17615 {
17616 arg2 = wxString_in_helper(obj1);
17617 if (arg2 == NULL) SWIG_fail;
17618 temp2 = true;
17619 }
17620 if (obj2) {
17621 {
17622 arg3 = (long)(SWIG_As_long(obj2));
17623 if (SWIG_arg_fail(3)) SWIG_fail;
17624 }
17625 }
17626 {
17627 PyThreadState* __tstate = wxPyBeginAllowThreads();
17628 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17629
17630 wxPyEndAllowThreads(__tstate);
17631 if (PyErr_Occurred()) SWIG_fail;
17632 }
17633 {
17634 resultobj = SWIG_From_long((long)(result));
17635 }
17636 {
17637 if (temp2)
17638 delete arg2;
17639 }
17640 return resultobj;
17641 fail:
17642 {
17643 if (temp2)
17644 delete arg2;
17645 }
17646 return NULL;
17647 }
17648
17649
17650 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17651 PyObject *resultobj;
17652 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17653 wxString *arg2 = 0 ;
17654 double arg3 = (double) 0.0 ;
17655 double result;
17656 bool temp2 = false ;
17657 PyObject * obj0 = 0 ;
17658 PyObject * obj1 = 0 ;
17659 PyObject * obj2 = 0 ;
17660 char *kwnames[] = {
17661 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17662 };
17663
17664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17666 if (SWIG_arg_fail(1)) SWIG_fail;
17667 {
17668 arg2 = wxString_in_helper(obj1);
17669 if (arg2 == NULL) SWIG_fail;
17670 temp2 = true;
17671 }
17672 if (obj2) {
17673 {
17674 arg3 = (double)(SWIG_As_double(obj2));
17675 if (SWIG_arg_fail(3)) SWIG_fail;
17676 }
17677 }
17678 {
17679 PyThreadState* __tstate = wxPyBeginAllowThreads();
17680 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17681
17682 wxPyEndAllowThreads(__tstate);
17683 if (PyErr_Occurred()) SWIG_fail;
17684 }
17685 {
17686 resultobj = SWIG_From_double((double)(result));
17687 }
17688 {
17689 if (temp2)
17690 delete arg2;
17691 }
17692 return resultobj;
17693 fail:
17694 {
17695 if (temp2)
17696 delete arg2;
17697 }
17698 return NULL;
17699 }
17700
17701
17702 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17703 PyObject *resultobj;
17704 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17705 wxString *arg2 = 0 ;
17706 bool arg3 = (bool) false ;
17707 bool result;
17708 bool temp2 = false ;
17709 PyObject * obj0 = 0 ;
17710 PyObject * obj1 = 0 ;
17711 PyObject * obj2 = 0 ;
17712 char *kwnames[] = {
17713 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17714 };
17715
17716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17718 if (SWIG_arg_fail(1)) SWIG_fail;
17719 {
17720 arg2 = wxString_in_helper(obj1);
17721 if (arg2 == NULL) SWIG_fail;
17722 temp2 = true;
17723 }
17724 if (obj2) {
17725 {
17726 arg3 = (bool)(SWIG_As_bool(obj2));
17727 if (SWIG_arg_fail(3)) SWIG_fail;
17728 }
17729 }
17730 {
17731 PyThreadState* __tstate = wxPyBeginAllowThreads();
17732 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17733
17734 wxPyEndAllowThreads(__tstate);
17735 if (PyErr_Occurred()) SWIG_fail;
17736 }
17737 {
17738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17739 }
17740 {
17741 if (temp2)
17742 delete arg2;
17743 }
17744 return resultobj;
17745 fail:
17746 {
17747 if (temp2)
17748 delete arg2;
17749 }
17750 return NULL;
17751 }
17752
17753
17754 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17755 PyObject *resultobj;
17756 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17757 wxString *arg2 = 0 ;
17758 wxString *arg3 = 0 ;
17759 bool result;
17760 bool temp2 = false ;
17761 bool temp3 = false ;
17762 PyObject * obj0 = 0 ;
17763 PyObject * obj1 = 0 ;
17764 PyObject * obj2 = 0 ;
17765 char *kwnames[] = {
17766 (char *) "self",(char *) "key",(char *) "value", NULL
17767 };
17768
17769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17771 if (SWIG_arg_fail(1)) SWIG_fail;
17772 {
17773 arg2 = wxString_in_helper(obj1);
17774 if (arg2 == NULL) SWIG_fail;
17775 temp2 = true;
17776 }
17777 {
17778 arg3 = wxString_in_helper(obj2);
17779 if (arg3 == NULL) SWIG_fail;
17780 temp3 = true;
17781 }
17782 {
17783 PyThreadState* __tstate = wxPyBeginAllowThreads();
17784 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17785
17786 wxPyEndAllowThreads(__tstate);
17787 if (PyErr_Occurred()) SWIG_fail;
17788 }
17789 {
17790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17791 }
17792 {
17793 if (temp2)
17794 delete arg2;
17795 }
17796 {
17797 if (temp3)
17798 delete arg3;
17799 }
17800 return resultobj;
17801 fail:
17802 {
17803 if (temp2)
17804 delete arg2;
17805 }
17806 {
17807 if (temp3)
17808 delete arg3;
17809 }
17810 return NULL;
17811 }
17812
17813
17814 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17815 PyObject *resultobj;
17816 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17817 wxString *arg2 = 0 ;
17818 long arg3 ;
17819 bool result;
17820 bool temp2 = false ;
17821 PyObject * obj0 = 0 ;
17822 PyObject * obj1 = 0 ;
17823 PyObject * obj2 = 0 ;
17824 char *kwnames[] = {
17825 (char *) "self",(char *) "key",(char *) "value", NULL
17826 };
17827
17828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17830 if (SWIG_arg_fail(1)) SWIG_fail;
17831 {
17832 arg2 = wxString_in_helper(obj1);
17833 if (arg2 == NULL) SWIG_fail;
17834 temp2 = true;
17835 }
17836 {
17837 arg3 = (long)(SWIG_As_long(obj2));
17838 if (SWIG_arg_fail(3)) SWIG_fail;
17839 }
17840 {
17841 PyThreadState* __tstate = wxPyBeginAllowThreads();
17842 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17843
17844 wxPyEndAllowThreads(__tstate);
17845 if (PyErr_Occurred()) SWIG_fail;
17846 }
17847 {
17848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17849 }
17850 {
17851 if (temp2)
17852 delete arg2;
17853 }
17854 return resultobj;
17855 fail:
17856 {
17857 if (temp2)
17858 delete arg2;
17859 }
17860 return NULL;
17861 }
17862
17863
17864 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17865 PyObject *resultobj;
17866 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17867 wxString *arg2 = 0 ;
17868 double arg3 ;
17869 bool result;
17870 bool temp2 = false ;
17871 PyObject * obj0 = 0 ;
17872 PyObject * obj1 = 0 ;
17873 PyObject * obj2 = 0 ;
17874 char *kwnames[] = {
17875 (char *) "self",(char *) "key",(char *) "value", NULL
17876 };
17877
17878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17880 if (SWIG_arg_fail(1)) SWIG_fail;
17881 {
17882 arg2 = wxString_in_helper(obj1);
17883 if (arg2 == NULL) SWIG_fail;
17884 temp2 = true;
17885 }
17886 {
17887 arg3 = (double)(SWIG_As_double(obj2));
17888 if (SWIG_arg_fail(3)) SWIG_fail;
17889 }
17890 {
17891 PyThreadState* __tstate = wxPyBeginAllowThreads();
17892 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17893
17894 wxPyEndAllowThreads(__tstate);
17895 if (PyErr_Occurred()) SWIG_fail;
17896 }
17897 {
17898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17899 }
17900 {
17901 if (temp2)
17902 delete arg2;
17903 }
17904 return resultobj;
17905 fail:
17906 {
17907 if (temp2)
17908 delete arg2;
17909 }
17910 return NULL;
17911 }
17912
17913
17914 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17915 PyObject *resultobj;
17916 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17917 wxString *arg2 = 0 ;
17918 bool arg3 ;
17919 bool result;
17920 bool temp2 = false ;
17921 PyObject * obj0 = 0 ;
17922 PyObject * obj1 = 0 ;
17923 PyObject * obj2 = 0 ;
17924 char *kwnames[] = {
17925 (char *) "self",(char *) "key",(char *) "value", NULL
17926 };
17927
17928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17930 if (SWIG_arg_fail(1)) SWIG_fail;
17931 {
17932 arg2 = wxString_in_helper(obj1);
17933 if (arg2 == NULL) SWIG_fail;
17934 temp2 = true;
17935 }
17936 {
17937 arg3 = (bool)(SWIG_As_bool(obj2));
17938 if (SWIG_arg_fail(3)) SWIG_fail;
17939 }
17940 {
17941 PyThreadState* __tstate = wxPyBeginAllowThreads();
17942 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17943
17944 wxPyEndAllowThreads(__tstate);
17945 if (PyErr_Occurred()) SWIG_fail;
17946 }
17947 {
17948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17949 }
17950 {
17951 if (temp2)
17952 delete arg2;
17953 }
17954 return resultobj;
17955 fail:
17956 {
17957 if (temp2)
17958 delete arg2;
17959 }
17960 return NULL;
17961 }
17962
17963
17964 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17965 PyObject *resultobj;
17966 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17967 bool arg2 = (bool) false ;
17968 bool result;
17969 PyObject * obj0 = 0 ;
17970 PyObject * obj1 = 0 ;
17971 char *kwnames[] = {
17972 (char *) "self",(char *) "currentOnly", NULL
17973 };
17974
17975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17977 if (SWIG_arg_fail(1)) SWIG_fail;
17978 if (obj1) {
17979 {
17980 arg2 = (bool)(SWIG_As_bool(obj1));
17981 if (SWIG_arg_fail(2)) SWIG_fail;
17982 }
17983 }
17984 {
17985 PyThreadState* __tstate = wxPyBeginAllowThreads();
17986 result = (bool)(arg1)->Flush(arg2);
17987
17988 wxPyEndAllowThreads(__tstate);
17989 if (PyErr_Occurred()) SWIG_fail;
17990 }
17991 {
17992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17993 }
17994 return resultobj;
17995 fail:
17996 return NULL;
17997 }
17998
17999
18000 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18001 PyObject *resultobj;
18002 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18003 wxString *arg2 = 0 ;
18004 wxString *arg3 = 0 ;
18005 bool result;
18006 bool temp2 = false ;
18007 bool temp3 = false ;
18008 PyObject * obj0 = 0 ;
18009 PyObject * obj1 = 0 ;
18010 PyObject * obj2 = 0 ;
18011 char *kwnames[] = {
18012 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18013 };
18014
18015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18017 if (SWIG_arg_fail(1)) SWIG_fail;
18018 {
18019 arg2 = wxString_in_helper(obj1);
18020 if (arg2 == NULL) SWIG_fail;
18021 temp2 = true;
18022 }
18023 {
18024 arg3 = wxString_in_helper(obj2);
18025 if (arg3 == NULL) SWIG_fail;
18026 temp3 = true;
18027 }
18028 {
18029 PyThreadState* __tstate = wxPyBeginAllowThreads();
18030 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
18031
18032 wxPyEndAllowThreads(__tstate);
18033 if (PyErr_Occurred()) SWIG_fail;
18034 }
18035 {
18036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18037 }
18038 {
18039 if (temp2)
18040 delete arg2;
18041 }
18042 {
18043 if (temp3)
18044 delete arg3;
18045 }
18046 return resultobj;
18047 fail:
18048 {
18049 if (temp2)
18050 delete arg2;
18051 }
18052 {
18053 if (temp3)
18054 delete arg3;
18055 }
18056 return NULL;
18057 }
18058
18059
18060 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18061 PyObject *resultobj;
18062 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18063 wxString *arg2 = 0 ;
18064 wxString *arg3 = 0 ;
18065 bool result;
18066 bool temp2 = false ;
18067 bool temp3 = false ;
18068 PyObject * obj0 = 0 ;
18069 PyObject * obj1 = 0 ;
18070 PyObject * obj2 = 0 ;
18071 char *kwnames[] = {
18072 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18073 };
18074
18075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18077 if (SWIG_arg_fail(1)) SWIG_fail;
18078 {
18079 arg2 = wxString_in_helper(obj1);
18080 if (arg2 == NULL) SWIG_fail;
18081 temp2 = true;
18082 }
18083 {
18084 arg3 = wxString_in_helper(obj2);
18085 if (arg3 == NULL) SWIG_fail;
18086 temp3 = true;
18087 }
18088 {
18089 PyThreadState* __tstate = wxPyBeginAllowThreads();
18090 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18091
18092 wxPyEndAllowThreads(__tstate);
18093 if (PyErr_Occurred()) SWIG_fail;
18094 }
18095 {
18096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18097 }
18098 {
18099 if (temp2)
18100 delete arg2;
18101 }
18102 {
18103 if (temp3)
18104 delete arg3;
18105 }
18106 return resultobj;
18107 fail:
18108 {
18109 if (temp2)
18110 delete arg2;
18111 }
18112 {
18113 if (temp3)
18114 delete arg3;
18115 }
18116 return NULL;
18117 }
18118
18119
18120 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18121 PyObject *resultobj;
18122 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18123 wxString *arg2 = 0 ;
18124 bool arg3 = (bool) true ;
18125 bool result;
18126 bool temp2 = false ;
18127 PyObject * obj0 = 0 ;
18128 PyObject * obj1 = 0 ;
18129 PyObject * obj2 = 0 ;
18130 char *kwnames[] = {
18131 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18132 };
18133
18134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18136 if (SWIG_arg_fail(1)) SWIG_fail;
18137 {
18138 arg2 = wxString_in_helper(obj1);
18139 if (arg2 == NULL) SWIG_fail;
18140 temp2 = true;
18141 }
18142 if (obj2) {
18143 {
18144 arg3 = (bool)(SWIG_As_bool(obj2));
18145 if (SWIG_arg_fail(3)) SWIG_fail;
18146 }
18147 }
18148 {
18149 PyThreadState* __tstate = wxPyBeginAllowThreads();
18150 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18151
18152 wxPyEndAllowThreads(__tstate);
18153 if (PyErr_Occurred()) SWIG_fail;
18154 }
18155 {
18156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18157 }
18158 {
18159 if (temp2)
18160 delete arg2;
18161 }
18162 return resultobj;
18163 fail:
18164 {
18165 if (temp2)
18166 delete arg2;
18167 }
18168 return NULL;
18169 }
18170
18171
18172 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18173 PyObject *resultobj;
18174 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18175 wxString *arg2 = 0 ;
18176 bool result;
18177 bool temp2 = false ;
18178 PyObject * obj0 = 0 ;
18179 PyObject * obj1 = 0 ;
18180 char *kwnames[] = {
18181 (char *) "self",(char *) "key", NULL
18182 };
18183
18184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18186 if (SWIG_arg_fail(1)) SWIG_fail;
18187 {
18188 arg2 = wxString_in_helper(obj1);
18189 if (arg2 == NULL) SWIG_fail;
18190 temp2 = true;
18191 }
18192 {
18193 PyThreadState* __tstate = wxPyBeginAllowThreads();
18194 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18195
18196 wxPyEndAllowThreads(__tstate);
18197 if (PyErr_Occurred()) SWIG_fail;
18198 }
18199 {
18200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18201 }
18202 {
18203 if (temp2)
18204 delete arg2;
18205 }
18206 return resultobj;
18207 fail:
18208 {
18209 if (temp2)
18210 delete arg2;
18211 }
18212 return NULL;
18213 }
18214
18215
18216 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18217 PyObject *resultobj;
18218 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18219 bool result;
18220 PyObject * obj0 = 0 ;
18221 char *kwnames[] = {
18222 (char *) "self", NULL
18223 };
18224
18225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18227 if (SWIG_arg_fail(1)) SWIG_fail;
18228 {
18229 PyThreadState* __tstate = wxPyBeginAllowThreads();
18230 result = (bool)(arg1)->DeleteAll();
18231
18232 wxPyEndAllowThreads(__tstate);
18233 if (PyErr_Occurred()) SWIG_fail;
18234 }
18235 {
18236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18237 }
18238 return resultobj;
18239 fail:
18240 return NULL;
18241 }
18242
18243
18244 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18245 PyObject *resultobj;
18246 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18247 bool arg2 = (bool) true ;
18248 PyObject * obj0 = 0 ;
18249 PyObject * obj1 = 0 ;
18250 char *kwnames[] = {
18251 (char *) "self",(char *) "doIt", NULL
18252 };
18253
18254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18256 if (SWIG_arg_fail(1)) SWIG_fail;
18257 if (obj1) {
18258 {
18259 arg2 = (bool)(SWIG_As_bool(obj1));
18260 if (SWIG_arg_fail(2)) SWIG_fail;
18261 }
18262 }
18263 {
18264 PyThreadState* __tstate = wxPyBeginAllowThreads();
18265 (arg1)->SetExpandEnvVars(arg2);
18266
18267 wxPyEndAllowThreads(__tstate);
18268 if (PyErr_Occurred()) SWIG_fail;
18269 }
18270 Py_INCREF(Py_None); resultobj = Py_None;
18271 return resultobj;
18272 fail:
18273 return NULL;
18274 }
18275
18276
18277 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18278 PyObject *resultobj;
18279 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18280 bool result;
18281 PyObject * obj0 = 0 ;
18282 char *kwnames[] = {
18283 (char *) "self", NULL
18284 };
18285
18286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18288 if (SWIG_arg_fail(1)) SWIG_fail;
18289 {
18290 PyThreadState* __tstate = wxPyBeginAllowThreads();
18291 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18292
18293 wxPyEndAllowThreads(__tstate);
18294 if (PyErr_Occurred()) SWIG_fail;
18295 }
18296 {
18297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18298 }
18299 return resultobj;
18300 fail:
18301 return NULL;
18302 }
18303
18304
18305 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18306 PyObject *resultobj;
18307 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18308 bool arg2 = (bool) true ;
18309 PyObject * obj0 = 0 ;
18310 PyObject * obj1 = 0 ;
18311 char *kwnames[] = {
18312 (char *) "self",(char *) "doIt", NULL
18313 };
18314
18315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18317 if (SWIG_arg_fail(1)) SWIG_fail;
18318 if (obj1) {
18319 {
18320 arg2 = (bool)(SWIG_As_bool(obj1));
18321 if (SWIG_arg_fail(2)) SWIG_fail;
18322 }
18323 }
18324 {
18325 PyThreadState* __tstate = wxPyBeginAllowThreads();
18326 (arg1)->SetRecordDefaults(arg2);
18327
18328 wxPyEndAllowThreads(__tstate);
18329 if (PyErr_Occurred()) SWIG_fail;
18330 }
18331 Py_INCREF(Py_None); resultobj = Py_None;
18332 return resultobj;
18333 fail:
18334 return NULL;
18335 }
18336
18337
18338 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18339 PyObject *resultobj;
18340 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18341 bool result;
18342 PyObject * obj0 = 0 ;
18343 char *kwnames[] = {
18344 (char *) "self", NULL
18345 };
18346
18347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18349 if (SWIG_arg_fail(1)) SWIG_fail;
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18353
18354 wxPyEndAllowThreads(__tstate);
18355 if (PyErr_Occurred()) SWIG_fail;
18356 }
18357 {
18358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18359 }
18360 return resultobj;
18361 fail:
18362 return NULL;
18363 }
18364
18365
18366 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18367 PyObject *resultobj;
18368 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18369 wxString *arg2 = 0 ;
18370 wxString result;
18371 bool temp2 = false ;
18372 PyObject * obj0 = 0 ;
18373 PyObject * obj1 = 0 ;
18374 char *kwnames[] = {
18375 (char *) "self",(char *) "str", NULL
18376 };
18377
18378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18380 if (SWIG_arg_fail(1)) SWIG_fail;
18381 {
18382 arg2 = wxString_in_helper(obj1);
18383 if (arg2 == NULL) SWIG_fail;
18384 temp2 = true;
18385 }
18386 {
18387 PyThreadState* __tstate = wxPyBeginAllowThreads();
18388 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18389
18390 wxPyEndAllowThreads(__tstate);
18391 if (PyErr_Occurred()) SWIG_fail;
18392 }
18393 {
18394 #if wxUSE_UNICODE
18395 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18396 #else
18397 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18398 #endif
18399 }
18400 {
18401 if (temp2)
18402 delete arg2;
18403 }
18404 return resultobj;
18405 fail:
18406 {
18407 if (temp2)
18408 delete arg2;
18409 }
18410 return NULL;
18411 }
18412
18413
18414 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18415 PyObject *resultobj;
18416 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18417 wxString result;
18418 PyObject * obj0 = 0 ;
18419 char *kwnames[] = {
18420 (char *) "self", NULL
18421 };
18422
18423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18425 if (SWIG_arg_fail(1)) SWIG_fail;
18426 {
18427 PyThreadState* __tstate = wxPyBeginAllowThreads();
18428 result = ((wxConfigBase const *)arg1)->GetAppName();
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 *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18447 PyObject *resultobj;
18448 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18449 wxString result;
18450 PyObject * obj0 = 0 ;
18451 char *kwnames[] = {
18452 (char *) "self", NULL
18453 };
18454
18455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18457 if (SWIG_arg_fail(1)) SWIG_fail;
18458 {
18459 PyThreadState* __tstate = wxPyBeginAllowThreads();
18460 result = ((wxConfigBase const *)arg1)->GetVendorName();
18461
18462 wxPyEndAllowThreads(__tstate);
18463 if (PyErr_Occurred()) SWIG_fail;
18464 }
18465 {
18466 #if wxUSE_UNICODE
18467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18468 #else
18469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18470 #endif
18471 }
18472 return resultobj;
18473 fail:
18474 return NULL;
18475 }
18476
18477
18478 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18479 PyObject *resultobj;
18480 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18481 wxString *arg2 = 0 ;
18482 bool temp2 = false ;
18483 PyObject * obj0 = 0 ;
18484 PyObject * obj1 = 0 ;
18485 char *kwnames[] = {
18486 (char *) "self",(char *) "appName", NULL
18487 };
18488
18489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18491 if (SWIG_arg_fail(1)) SWIG_fail;
18492 {
18493 arg2 = wxString_in_helper(obj1);
18494 if (arg2 == NULL) SWIG_fail;
18495 temp2 = true;
18496 }
18497 {
18498 PyThreadState* __tstate = wxPyBeginAllowThreads();
18499 (arg1)->SetAppName((wxString const &)*arg2);
18500
18501 wxPyEndAllowThreads(__tstate);
18502 if (PyErr_Occurred()) SWIG_fail;
18503 }
18504 Py_INCREF(Py_None); resultobj = Py_None;
18505 {
18506 if (temp2)
18507 delete arg2;
18508 }
18509 return resultobj;
18510 fail:
18511 {
18512 if (temp2)
18513 delete arg2;
18514 }
18515 return NULL;
18516 }
18517
18518
18519 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18520 PyObject *resultobj;
18521 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18522 wxString *arg2 = 0 ;
18523 bool temp2 = false ;
18524 PyObject * obj0 = 0 ;
18525 PyObject * obj1 = 0 ;
18526 char *kwnames[] = {
18527 (char *) "self",(char *) "vendorName", NULL
18528 };
18529
18530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18532 if (SWIG_arg_fail(1)) SWIG_fail;
18533 {
18534 arg2 = wxString_in_helper(obj1);
18535 if (arg2 == NULL) SWIG_fail;
18536 temp2 = true;
18537 }
18538 {
18539 PyThreadState* __tstate = wxPyBeginAllowThreads();
18540 (arg1)->SetVendorName((wxString const &)*arg2);
18541
18542 wxPyEndAllowThreads(__tstate);
18543 if (PyErr_Occurred()) SWIG_fail;
18544 }
18545 Py_INCREF(Py_None); resultobj = Py_None;
18546 {
18547 if (temp2)
18548 delete arg2;
18549 }
18550 return resultobj;
18551 fail:
18552 {
18553 if (temp2)
18554 delete arg2;
18555 }
18556 return NULL;
18557 }
18558
18559
18560 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18561 PyObject *resultobj;
18562 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18563 long arg2 ;
18564 PyObject * obj0 = 0 ;
18565 PyObject * obj1 = 0 ;
18566 char *kwnames[] = {
18567 (char *) "self",(char *) "style", NULL
18568 };
18569
18570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18572 if (SWIG_arg_fail(1)) SWIG_fail;
18573 {
18574 arg2 = (long)(SWIG_As_long(obj1));
18575 if (SWIG_arg_fail(2)) SWIG_fail;
18576 }
18577 {
18578 PyThreadState* __tstate = wxPyBeginAllowThreads();
18579 (arg1)->SetStyle(arg2);
18580
18581 wxPyEndAllowThreads(__tstate);
18582 if (PyErr_Occurred()) SWIG_fail;
18583 }
18584 Py_INCREF(Py_None); resultobj = Py_None;
18585 return resultobj;
18586 fail:
18587 return NULL;
18588 }
18589
18590
18591 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18592 PyObject *resultobj;
18593 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18594 long result;
18595 PyObject * obj0 = 0 ;
18596 char *kwnames[] = {
18597 (char *) "self", NULL
18598 };
18599
18600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18602 if (SWIG_arg_fail(1)) SWIG_fail;
18603 {
18604 PyThreadState* __tstate = wxPyBeginAllowThreads();
18605 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18606
18607 wxPyEndAllowThreads(__tstate);
18608 if (PyErr_Occurred()) SWIG_fail;
18609 }
18610 {
18611 resultobj = SWIG_From_long((long)(result));
18612 }
18613 return resultobj;
18614 fail:
18615 return NULL;
18616 }
18617
18618
18619 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18620 PyObject *obj;
18621 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18622 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18623 Py_INCREF(obj);
18624 return Py_BuildValue((char *)"");
18625 }
18626 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18627 PyObject *resultobj;
18628 wxString const &arg1_defvalue = wxPyEmptyString ;
18629 wxString *arg1 = (wxString *) &arg1_defvalue ;
18630 wxString const &arg2_defvalue = wxPyEmptyString ;
18631 wxString *arg2 = (wxString *) &arg2_defvalue ;
18632 wxString const &arg3_defvalue = wxPyEmptyString ;
18633 wxString *arg3 = (wxString *) &arg3_defvalue ;
18634 wxString const &arg4_defvalue = wxPyEmptyString ;
18635 wxString *arg4 = (wxString *) &arg4_defvalue ;
18636 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18637 wxConfig *result;
18638 bool temp1 = false ;
18639 bool temp2 = false ;
18640 bool temp3 = false ;
18641 bool temp4 = false ;
18642 PyObject * obj0 = 0 ;
18643 PyObject * obj1 = 0 ;
18644 PyObject * obj2 = 0 ;
18645 PyObject * obj3 = 0 ;
18646 PyObject * obj4 = 0 ;
18647 char *kwnames[] = {
18648 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18649 };
18650
18651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18652 if (obj0) {
18653 {
18654 arg1 = wxString_in_helper(obj0);
18655 if (arg1 == NULL) SWIG_fail;
18656 temp1 = true;
18657 }
18658 }
18659 if (obj1) {
18660 {
18661 arg2 = wxString_in_helper(obj1);
18662 if (arg2 == NULL) SWIG_fail;
18663 temp2 = true;
18664 }
18665 }
18666 if (obj2) {
18667 {
18668 arg3 = wxString_in_helper(obj2);
18669 if (arg3 == NULL) SWIG_fail;
18670 temp3 = true;
18671 }
18672 }
18673 if (obj3) {
18674 {
18675 arg4 = wxString_in_helper(obj3);
18676 if (arg4 == NULL) SWIG_fail;
18677 temp4 = true;
18678 }
18679 }
18680 if (obj4) {
18681 {
18682 arg5 = (long)(SWIG_As_long(obj4));
18683 if (SWIG_arg_fail(5)) SWIG_fail;
18684 }
18685 }
18686 {
18687 PyThreadState* __tstate = wxPyBeginAllowThreads();
18688 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18689
18690 wxPyEndAllowThreads(__tstate);
18691 if (PyErr_Occurred()) SWIG_fail;
18692 }
18693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18694 {
18695 if (temp1)
18696 delete arg1;
18697 }
18698 {
18699 if (temp2)
18700 delete arg2;
18701 }
18702 {
18703 if (temp3)
18704 delete arg3;
18705 }
18706 {
18707 if (temp4)
18708 delete arg4;
18709 }
18710 return resultobj;
18711 fail:
18712 {
18713 if (temp1)
18714 delete arg1;
18715 }
18716 {
18717 if (temp2)
18718 delete arg2;
18719 }
18720 {
18721 if (temp3)
18722 delete arg3;
18723 }
18724 {
18725 if (temp4)
18726 delete arg4;
18727 }
18728 return NULL;
18729 }
18730
18731
18732 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18733 PyObject *resultobj;
18734 wxConfig *arg1 = (wxConfig *) 0 ;
18735 PyObject * obj0 = 0 ;
18736 char *kwnames[] = {
18737 (char *) "self", NULL
18738 };
18739
18740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18742 if (SWIG_arg_fail(1)) SWIG_fail;
18743 {
18744 PyThreadState* __tstate = wxPyBeginAllowThreads();
18745 delete arg1;
18746
18747 wxPyEndAllowThreads(__tstate);
18748 if (PyErr_Occurred()) SWIG_fail;
18749 }
18750 Py_INCREF(Py_None); resultobj = Py_None;
18751 return resultobj;
18752 fail:
18753 return NULL;
18754 }
18755
18756
18757 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18758 PyObject *obj;
18759 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18760 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18761 Py_INCREF(obj);
18762 return Py_BuildValue((char *)"");
18763 }
18764 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18765 PyObject *resultobj;
18766 wxString const &arg1_defvalue = wxPyEmptyString ;
18767 wxString *arg1 = (wxString *) &arg1_defvalue ;
18768 wxString const &arg2_defvalue = wxPyEmptyString ;
18769 wxString *arg2 = (wxString *) &arg2_defvalue ;
18770 wxString const &arg3_defvalue = wxPyEmptyString ;
18771 wxString *arg3 = (wxString *) &arg3_defvalue ;
18772 wxString const &arg4_defvalue = wxPyEmptyString ;
18773 wxString *arg4 = (wxString *) &arg4_defvalue ;
18774 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18775 wxFileConfig *result;
18776 bool temp1 = false ;
18777 bool temp2 = false ;
18778 bool temp3 = false ;
18779 bool temp4 = false ;
18780 PyObject * obj0 = 0 ;
18781 PyObject * obj1 = 0 ;
18782 PyObject * obj2 = 0 ;
18783 PyObject * obj3 = 0 ;
18784 PyObject * obj4 = 0 ;
18785 char *kwnames[] = {
18786 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18787 };
18788
18789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18790 if (obj0) {
18791 {
18792 arg1 = wxString_in_helper(obj0);
18793 if (arg1 == NULL) SWIG_fail;
18794 temp1 = true;
18795 }
18796 }
18797 if (obj1) {
18798 {
18799 arg2 = wxString_in_helper(obj1);
18800 if (arg2 == NULL) SWIG_fail;
18801 temp2 = true;
18802 }
18803 }
18804 if (obj2) {
18805 {
18806 arg3 = wxString_in_helper(obj2);
18807 if (arg3 == NULL) SWIG_fail;
18808 temp3 = true;
18809 }
18810 }
18811 if (obj3) {
18812 {
18813 arg4 = wxString_in_helper(obj3);
18814 if (arg4 == NULL) SWIG_fail;
18815 temp4 = true;
18816 }
18817 }
18818 if (obj4) {
18819 {
18820 arg5 = (long)(SWIG_As_long(obj4));
18821 if (SWIG_arg_fail(5)) SWIG_fail;
18822 }
18823 }
18824 {
18825 PyThreadState* __tstate = wxPyBeginAllowThreads();
18826 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18827
18828 wxPyEndAllowThreads(__tstate);
18829 if (PyErr_Occurred()) SWIG_fail;
18830 }
18831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18832 {
18833 if (temp1)
18834 delete arg1;
18835 }
18836 {
18837 if (temp2)
18838 delete arg2;
18839 }
18840 {
18841 if (temp3)
18842 delete arg3;
18843 }
18844 {
18845 if (temp4)
18846 delete arg4;
18847 }
18848 return resultobj;
18849 fail:
18850 {
18851 if (temp1)
18852 delete arg1;
18853 }
18854 {
18855 if (temp2)
18856 delete arg2;
18857 }
18858 {
18859 if (temp3)
18860 delete arg3;
18861 }
18862 {
18863 if (temp4)
18864 delete arg4;
18865 }
18866 return NULL;
18867 }
18868
18869
18870 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18871 PyObject *resultobj;
18872 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18873 PyObject * obj0 = 0 ;
18874 char *kwnames[] = {
18875 (char *) "self", NULL
18876 };
18877
18878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18880 if (SWIG_arg_fail(1)) SWIG_fail;
18881 {
18882 PyThreadState* __tstate = wxPyBeginAllowThreads();
18883 delete arg1;
18884
18885 wxPyEndAllowThreads(__tstate);
18886 if (PyErr_Occurred()) SWIG_fail;
18887 }
18888 Py_INCREF(Py_None); resultobj = Py_None;
18889 return resultobj;
18890 fail:
18891 return NULL;
18892 }
18893
18894
18895 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18896 PyObject *obj;
18897 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18898 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18899 Py_INCREF(obj);
18900 return Py_BuildValue((char *)"");
18901 }
18902 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18903 PyObject *resultobj;
18904 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18905 wxString *arg2 = 0 ;
18906 wxConfigPathChanger *result;
18907 bool temp2 = false ;
18908 PyObject * obj0 = 0 ;
18909 PyObject * obj1 = 0 ;
18910 char *kwnames[] = {
18911 (char *) "config",(char *) "entry", NULL
18912 };
18913
18914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18916 if (SWIG_arg_fail(1)) SWIG_fail;
18917 {
18918 arg2 = wxString_in_helper(obj1);
18919 if (arg2 == NULL) SWIG_fail;
18920 temp2 = true;
18921 }
18922 {
18923 PyThreadState* __tstate = wxPyBeginAllowThreads();
18924 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18925
18926 wxPyEndAllowThreads(__tstate);
18927 if (PyErr_Occurred()) SWIG_fail;
18928 }
18929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18930 {
18931 if (temp2)
18932 delete arg2;
18933 }
18934 return resultobj;
18935 fail:
18936 {
18937 if (temp2)
18938 delete arg2;
18939 }
18940 return NULL;
18941 }
18942
18943
18944 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18945 PyObject *resultobj;
18946 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18947 PyObject * obj0 = 0 ;
18948 char *kwnames[] = {
18949 (char *) "self", NULL
18950 };
18951
18952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18954 if (SWIG_arg_fail(1)) SWIG_fail;
18955 {
18956 PyThreadState* __tstate = wxPyBeginAllowThreads();
18957 delete arg1;
18958
18959 wxPyEndAllowThreads(__tstate);
18960 if (PyErr_Occurred()) SWIG_fail;
18961 }
18962 Py_INCREF(Py_None); resultobj = Py_None;
18963 return resultobj;
18964 fail:
18965 return NULL;
18966 }
18967
18968
18969 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18970 PyObject *resultobj;
18971 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18972 wxString *result;
18973 PyObject * obj0 = 0 ;
18974 char *kwnames[] = {
18975 (char *) "self", NULL
18976 };
18977
18978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18980 if (SWIG_arg_fail(1)) SWIG_fail;
18981 {
18982 PyThreadState* __tstate = wxPyBeginAllowThreads();
18983 {
18984 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18985 result = (wxString *) &_result_ref;
18986 }
18987
18988 wxPyEndAllowThreads(__tstate);
18989 if (PyErr_Occurred()) SWIG_fail;
18990 }
18991 {
18992 #if wxUSE_UNICODE
18993 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18994 #else
18995 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18996 #endif
18997 }
18998 return resultobj;
18999 fail:
19000 return NULL;
19001 }
19002
19003
19004 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
19005 PyObject *obj;
19006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19007 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
19008 Py_INCREF(obj);
19009 return Py_BuildValue((char *)"");
19010 }
19011 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19012 PyObject *resultobj;
19013 wxString *arg1 = 0 ;
19014 wxString result;
19015 bool temp1 = false ;
19016 PyObject * obj0 = 0 ;
19017 char *kwnames[] = {
19018 (char *) "sz", NULL
19019 };
19020
19021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
19022 {
19023 arg1 = wxString_in_helper(obj0);
19024 if (arg1 == NULL) SWIG_fail;
19025 temp1 = true;
19026 }
19027 {
19028 PyThreadState* __tstate = wxPyBeginAllowThreads();
19029 result = wxExpandEnvVars((wxString const &)*arg1);
19030
19031 wxPyEndAllowThreads(__tstate);
19032 if (PyErr_Occurred()) SWIG_fail;
19033 }
19034 {
19035 #if wxUSE_UNICODE
19036 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19037 #else
19038 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19039 #endif
19040 }
19041 {
19042 if (temp1)
19043 delete arg1;
19044 }
19045 return resultobj;
19046 fail:
19047 {
19048 if (temp1)
19049 delete arg1;
19050 }
19051 return NULL;
19052 }
19053
19054
19055 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19056 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19057 return 1;
19058 }
19059
19060
19061 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19062 PyObject *pyobj;
19063
19064 {
19065 #if wxUSE_UNICODE
19066 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19067 #else
19068 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19069 #endif
19070 }
19071 return pyobj;
19072 }
19073
19074
19075 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19076 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19077 return 1;
19078 }
19079
19080
19081 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19082 PyObject *pyobj;
19083
19084 {
19085 #if wxUSE_UNICODE
19086 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19087 #else
19088 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19089 #endif
19090 }
19091 return pyobj;
19092 }
19093
19094
19095 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19096 PyObject *resultobj;
19097 wxDateTime::Country arg1 ;
19098 PyObject * obj0 = 0 ;
19099 char *kwnames[] = {
19100 (char *) "country", NULL
19101 };
19102
19103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19104 {
19105 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19106 if (SWIG_arg_fail(1)) SWIG_fail;
19107 }
19108 {
19109 PyThreadState* __tstate = wxPyBeginAllowThreads();
19110 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19111
19112 wxPyEndAllowThreads(__tstate);
19113 if (PyErr_Occurred()) SWIG_fail;
19114 }
19115 Py_INCREF(Py_None); resultobj = Py_None;
19116 return resultobj;
19117 fail:
19118 return NULL;
19119 }
19120
19121
19122 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19123 PyObject *resultobj;
19124 wxDateTime::Country result;
19125 char *kwnames[] = {
19126 NULL
19127 };
19128
19129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19130 {
19131 PyThreadState* __tstate = wxPyBeginAllowThreads();
19132 result = (wxDateTime::Country)wxDateTime::GetCountry();
19133
19134 wxPyEndAllowThreads(__tstate);
19135 if (PyErr_Occurred()) SWIG_fail;
19136 }
19137 resultobj = SWIG_From_int((result));
19138 return resultobj;
19139 fail:
19140 return NULL;
19141 }
19142
19143
19144 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19145 PyObject *resultobj;
19146 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19147 bool result;
19148 PyObject * obj0 = 0 ;
19149 char *kwnames[] = {
19150 (char *) "country", NULL
19151 };
19152
19153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19154 if (obj0) {
19155 {
19156 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19157 if (SWIG_arg_fail(1)) SWIG_fail;
19158 }
19159 }
19160 {
19161 PyThreadState* __tstate = wxPyBeginAllowThreads();
19162 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19163
19164 wxPyEndAllowThreads(__tstate);
19165 if (PyErr_Occurred()) SWIG_fail;
19166 }
19167 {
19168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19169 }
19170 return resultobj;
19171 fail:
19172 return NULL;
19173 }
19174
19175
19176 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19177 PyObject *resultobj;
19178 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19179 int result;
19180 PyObject * obj0 = 0 ;
19181 char *kwnames[] = {
19182 (char *) "cal", NULL
19183 };
19184
19185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19186 if (obj0) {
19187 {
19188 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19189 if (SWIG_arg_fail(1)) SWIG_fail;
19190 }
19191 }
19192 {
19193 PyThreadState* __tstate = wxPyBeginAllowThreads();
19194 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19195
19196 wxPyEndAllowThreads(__tstate);
19197 if (PyErr_Occurred()) SWIG_fail;
19198 }
19199 {
19200 resultobj = SWIG_From_int((int)(result));
19201 }
19202 return resultobj;
19203 fail:
19204 return NULL;
19205 }
19206
19207
19208 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19209 PyObject *resultobj;
19210 int arg1 ;
19211 int result;
19212 PyObject * obj0 = 0 ;
19213 char *kwnames[] = {
19214 (char *) "year", NULL
19215 };
19216
19217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19218 {
19219 arg1 = (int)(SWIG_As_int(obj0));
19220 if (SWIG_arg_fail(1)) SWIG_fail;
19221 }
19222 {
19223 PyThreadState* __tstate = wxPyBeginAllowThreads();
19224 result = (int)wxDateTime::ConvertYearToBC(arg1);
19225
19226 wxPyEndAllowThreads(__tstate);
19227 if (PyErr_Occurred()) SWIG_fail;
19228 }
19229 {
19230 resultobj = SWIG_From_int((int)(result));
19231 }
19232 return resultobj;
19233 fail:
19234 return NULL;
19235 }
19236
19237
19238 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19239 PyObject *resultobj;
19240 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19241 wxDateTime::Month result;
19242 PyObject * obj0 = 0 ;
19243 char *kwnames[] = {
19244 (char *) "cal", NULL
19245 };
19246
19247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19248 if (obj0) {
19249 {
19250 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19251 if (SWIG_arg_fail(1)) SWIG_fail;
19252 }
19253 }
19254 {
19255 PyThreadState* __tstate = wxPyBeginAllowThreads();
19256 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19257
19258 wxPyEndAllowThreads(__tstate);
19259 if (PyErr_Occurred()) SWIG_fail;
19260 }
19261 resultobj = SWIG_From_int((result));
19262 return resultobj;
19263 fail:
19264 return NULL;
19265 }
19266
19267
19268 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19269 PyObject *resultobj;
19270 int arg1 = (int) wxDateTime::Inv_Year ;
19271 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19272 bool result;
19273 PyObject * obj0 = 0 ;
19274 PyObject * obj1 = 0 ;
19275 char *kwnames[] = {
19276 (char *) "year",(char *) "cal", NULL
19277 };
19278
19279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19280 if (obj0) {
19281 {
19282 arg1 = (int)(SWIG_As_int(obj0));
19283 if (SWIG_arg_fail(1)) SWIG_fail;
19284 }
19285 }
19286 if (obj1) {
19287 {
19288 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19289 if (SWIG_arg_fail(2)) SWIG_fail;
19290 }
19291 }
19292 {
19293 PyThreadState* __tstate = wxPyBeginAllowThreads();
19294 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19295
19296 wxPyEndAllowThreads(__tstate);
19297 if (PyErr_Occurred()) SWIG_fail;
19298 }
19299 {
19300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19301 }
19302 return resultobj;
19303 fail:
19304 return NULL;
19305 }
19306
19307
19308 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19309 PyObject *resultobj;
19310 int arg1 = (int) wxDateTime::Inv_Year ;
19311 int result;
19312 PyObject * obj0 = 0 ;
19313 char *kwnames[] = {
19314 (char *) "year", NULL
19315 };
19316
19317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19318 if (obj0) {
19319 {
19320 arg1 = (int)(SWIG_As_int(obj0));
19321 if (SWIG_arg_fail(1)) SWIG_fail;
19322 }
19323 }
19324 {
19325 PyThreadState* __tstate = wxPyBeginAllowThreads();
19326 result = (int)wxDateTime::GetCentury(arg1);
19327
19328 wxPyEndAllowThreads(__tstate);
19329 if (PyErr_Occurred()) SWIG_fail;
19330 }
19331 {
19332 resultobj = SWIG_From_int((int)(result));
19333 }
19334 return resultobj;
19335 fail:
19336 return NULL;
19337 }
19338
19339
19340 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19341 PyObject *resultobj;
19342 int arg1 ;
19343 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19344 int result;
19345 PyObject * obj0 = 0 ;
19346 PyObject * obj1 = 0 ;
19347 char *kwnames[] = {
19348 (char *) "year",(char *) "cal", NULL
19349 };
19350
19351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19352 {
19353 arg1 = (int)(SWIG_As_int(obj0));
19354 if (SWIG_arg_fail(1)) SWIG_fail;
19355 }
19356 if (obj1) {
19357 {
19358 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19359 if (SWIG_arg_fail(2)) SWIG_fail;
19360 }
19361 }
19362 {
19363 PyThreadState* __tstate = wxPyBeginAllowThreads();
19364 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19365
19366 wxPyEndAllowThreads(__tstate);
19367 if (PyErr_Occurred()) SWIG_fail;
19368 }
19369 {
19370 resultobj = SWIG_From_int((int)(result));
19371 }
19372 return resultobj;
19373 fail:
19374 return NULL;
19375 }
19376
19377
19378 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19379 PyObject *resultobj;
19380 wxDateTime::Month arg1 ;
19381 int arg2 = (int) wxDateTime::Inv_Year ;
19382 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19383 int result;
19384 PyObject * obj0 = 0 ;
19385 PyObject * obj1 = 0 ;
19386 PyObject * obj2 = 0 ;
19387 char *kwnames[] = {
19388 (char *) "month",(char *) "year",(char *) "cal", NULL
19389 };
19390
19391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19392 {
19393 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19394 if (SWIG_arg_fail(1)) SWIG_fail;
19395 }
19396 if (obj1) {
19397 {
19398 arg2 = (int)(SWIG_As_int(obj1));
19399 if (SWIG_arg_fail(2)) SWIG_fail;
19400 }
19401 }
19402 if (obj2) {
19403 {
19404 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19405 if (SWIG_arg_fail(3)) SWIG_fail;
19406 }
19407 }
19408 {
19409 PyThreadState* __tstate = wxPyBeginAllowThreads();
19410 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19411
19412 wxPyEndAllowThreads(__tstate);
19413 if (PyErr_Occurred()) SWIG_fail;
19414 }
19415 {
19416 resultobj = SWIG_From_int((int)(result));
19417 }
19418 return resultobj;
19419 fail:
19420 return NULL;
19421 }
19422
19423
19424 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19425 PyObject *resultobj;
19426 wxDateTime::Month arg1 ;
19427 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19428 wxString result;
19429 PyObject * obj0 = 0 ;
19430 PyObject * obj1 = 0 ;
19431 char *kwnames[] = {
19432 (char *) "month",(char *) "flags", NULL
19433 };
19434
19435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19436 {
19437 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19438 if (SWIG_arg_fail(1)) SWIG_fail;
19439 }
19440 if (obj1) {
19441 {
19442 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19443 if (SWIG_arg_fail(2)) SWIG_fail;
19444 }
19445 }
19446 {
19447 PyThreadState* __tstate = wxPyBeginAllowThreads();
19448 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19449
19450 wxPyEndAllowThreads(__tstate);
19451 if (PyErr_Occurred()) SWIG_fail;
19452 }
19453 {
19454 #if wxUSE_UNICODE
19455 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19456 #else
19457 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19458 #endif
19459 }
19460 return resultobj;
19461 fail:
19462 return NULL;
19463 }
19464
19465
19466 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19467 PyObject *resultobj;
19468 wxDateTime::WeekDay arg1 ;
19469 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19470 wxString result;
19471 PyObject * obj0 = 0 ;
19472 PyObject * obj1 = 0 ;
19473 char *kwnames[] = {
19474 (char *) "weekday",(char *) "flags", NULL
19475 };
19476
19477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19478 {
19479 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19480 if (SWIG_arg_fail(1)) SWIG_fail;
19481 }
19482 if (obj1) {
19483 {
19484 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19485 if (SWIG_arg_fail(2)) SWIG_fail;
19486 }
19487 }
19488 {
19489 PyThreadState* __tstate = wxPyBeginAllowThreads();
19490 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19491
19492 wxPyEndAllowThreads(__tstate);
19493 if (PyErr_Occurred()) SWIG_fail;
19494 }
19495 {
19496 #if wxUSE_UNICODE
19497 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19498 #else
19499 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19500 #endif
19501 }
19502 return resultobj;
19503 fail:
19504 return NULL;
19505 }
19506
19507
19508 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19509 PyObject *resultobj;
19510 PyObject *result;
19511 char *kwnames[] = {
19512 NULL
19513 };
19514
19515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19516 {
19517 PyThreadState* __tstate = wxPyBeginAllowThreads();
19518 result = (PyObject *)DateTime_GetAmPmStrings();
19519
19520 wxPyEndAllowThreads(__tstate);
19521 if (PyErr_Occurred()) SWIG_fail;
19522 }
19523 resultobj = result;
19524 return resultobj;
19525 fail:
19526 return NULL;
19527 }
19528
19529
19530 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19531 PyObject *resultobj;
19532 int arg1 = (int) wxDateTime::Inv_Year ;
19533 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19534 bool result;
19535 PyObject * obj0 = 0 ;
19536 PyObject * obj1 = 0 ;
19537 char *kwnames[] = {
19538 (char *) "year",(char *) "country", NULL
19539 };
19540
19541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19542 if (obj0) {
19543 {
19544 arg1 = (int)(SWIG_As_int(obj0));
19545 if (SWIG_arg_fail(1)) SWIG_fail;
19546 }
19547 }
19548 if (obj1) {
19549 {
19550 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19551 if (SWIG_arg_fail(2)) SWIG_fail;
19552 }
19553 }
19554 {
19555 PyThreadState* __tstate = wxPyBeginAllowThreads();
19556 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19557
19558 wxPyEndAllowThreads(__tstate);
19559 if (PyErr_Occurred()) SWIG_fail;
19560 }
19561 {
19562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19563 }
19564 return resultobj;
19565 fail:
19566 return NULL;
19567 }
19568
19569
19570 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19571 PyObject *resultobj;
19572 int arg1 = (int) wxDateTime::Inv_Year ;
19573 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19574 wxDateTime result;
19575 PyObject * obj0 = 0 ;
19576 PyObject * obj1 = 0 ;
19577 char *kwnames[] = {
19578 (char *) "year",(char *) "country", NULL
19579 };
19580
19581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19582 if (obj0) {
19583 {
19584 arg1 = (int)(SWIG_As_int(obj0));
19585 if (SWIG_arg_fail(1)) SWIG_fail;
19586 }
19587 }
19588 if (obj1) {
19589 {
19590 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19591 if (SWIG_arg_fail(2)) SWIG_fail;
19592 }
19593 }
19594 {
19595 PyThreadState* __tstate = wxPyBeginAllowThreads();
19596 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19597
19598 wxPyEndAllowThreads(__tstate);
19599 if (PyErr_Occurred()) SWIG_fail;
19600 }
19601 {
19602 wxDateTime * resultptr;
19603 resultptr = new wxDateTime((wxDateTime &)(result));
19604 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19605 }
19606 return resultobj;
19607 fail:
19608 return NULL;
19609 }
19610
19611
19612 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19613 PyObject *resultobj;
19614 int arg1 = (int) wxDateTime::Inv_Year ;
19615 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19616 wxDateTime result;
19617 PyObject * obj0 = 0 ;
19618 PyObject * obj1 = 0 ;
19619 char *kwnames[] = {
19620 (char *) "year",(char *) "country", NULL
19621 };
19622
19623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19624 if (obj0) {
19625 {
19626 arg1 = (int)(SWIG_As_int(obj0));
19627 if (SWIG_arg_fail(1)) SWIG_fail;
19628 }
19629 }
19630 if (obj1) {
19631 {
19632 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19633 if (SWIG_arg_fail(2)) SWIG_fail;
19634 }
19635 }
19636 {
19637 PyThreadState* __tstate = wxPyBeginAllowThreads();
19638 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19639
19640 wxPyEndAllowThreads(__tstate);
19641 if (PyErr_Occurred()) SWIG_fail;
19642 }
19643 {
19644 wxDateTime * resultptr;
19645 resultptr = new wxDateTime((wxDateTime &)(result));
19646 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19647 }
19648 return resultobj;
19649 fail:
19650 return NULL;
19651 }
19652
19653
19654 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19655 PyObject *resultobj;
19656 wxDateTime result;
19657 char *kwnames[] = {
19658 NULL
19659 };
19660
19661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19662 {
19663 PyThreadState* __tstate = wxPyBeginAllowThreads();
19664 result = wxDateTime::Now();
19665
19666 wxPyEndAllowThreads(__tstate);
19667 if (PyErr_Occurred()) SWIG_fail;
19668 }
19669 {
19670 wxDateTime * resultptr;
19671 resultptr = new wxDateTime((wxDateTime &)(result));
19672 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19673 }
19674 return resultobj;
19675 fail:
19676 return NULL;
19677 }
19678
19679
19680 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19681 PyObject *resultobj;
19682 wxDateTime result;
19683 char *kwnames[] = {
19684 NULL
19685 };
19686
19687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19688 {
19689 PyThreadState* __tstate = wxPyBeginAllowThreads();
19690 result = wxDateTime::UNow();
19691
19692 wxPyEndAllowThreads(__tstate);
19693 if (PyErr_Occurred()) SWIG_fail;
19694 }
19695 {
19696 wxDateTime * resultptr;
19697 resultptr = new wxDateTime((wxDateTime &)(result));
19698 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19699 }
19700 return resultobj;
19701 fail:
19702 return NULL;
19703 }
19704
19705
19706 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19707 PyObject *resultobj;
19708 wxDateTime result;
19709 char *kwnames[] = {
19710 NULL
19711 };
19712
19713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19714 {
19715 PyThreadState* __tstate = wxPyBeginAllowThreads();
19716 result = wxDateTime::Today();
19717
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 {
19722 wxDateTime * resultptr;
19723 resultptr = new wxDateTime((wxDateTime &)(result));
19724 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19725 }
19726 return resultobj;
19727 fail:
19728 return NULL;
19729 }
19730
19731
19732 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19733 PyObject *resultobj;
19734 wxDateTime *result;
19735 char *kwnames[] = {
19736 NULL
19737 };
19738
19739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19740 {
19741 PyThreadState* __tstate = wxPyBeginAllowThreads();
19742 result = (wxDateTime *)new wxDateTime();
19743
19744 wxPyEndAllowThreads(__tstate);
19745 if (PyErr_Occurred()) SWIG_fail;
19746 }
19747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19748 return resultobj;
19749 fail:
19750 return NULL;
19751 }
19752
19753
19754 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19755 PyObject *resultobj;
19756 time_t arg1 ;
19757 wxDateTime *result;
19758 PyObject * obj0 = 0 ;
19759 char *kwnames[] = {
19760 (char *) "timet", NULL
19761 };
19762
19763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19764 {
19765 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19766 if (SWIG_arg_fail(1)) SWIG_fail;
19767 }
19768 {
19769 PyThreadState* __tstate = wxPyBeginAllowThreads();
19770 result = (wxDateTime *)new wxDateTime(arg1);
19771
19772 wxPyEndAllowThreads(__tstate);
19773 if (PyErr_Occurred()) SWIG_fail;
19774 }
19775 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19776 return resultobj;
19777 fail:
19778 return NULL;
19779 }
19780
19781
19782 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19783 PyObject *resultobj;
19784 double arg1 ;
19785 wxDateTime *result;
19786 PyObject * obj0 = 0 ;
19787 char *kwnames[] = {
19788 (char *) "jdn", NULL
19789 };
19790
19791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19792 {
19793 arg1 = (double)(SWIG_As_double(obj0));
19794 if (SWIG_arg_fail(1)) SWIG_fail;
19795 }
19796 {
19797 PyThreadState* __tstate = wxPyBeginAllowThreads();
19798 result = (wxDateTime *)new wxDateTime(arg1);
19799
19800 wxPyEndAllowThreads(__tstate);
19801 if (PyErr_Occurred()) SWIG_fail;
19802 }
19803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19804 return resultobj;
19805 fail:
19806 return NULL;
19807 }
19808
19809
19810 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19811 PyObject *resultobj;
19812 int arg1 ;
19813 int arg2 = (int) 0 ;
19814 int arg3 = (int) 0 ;
19815 int arg4 = (int) 0 ;
19816 wxDateTime *result;
19817 PyObject * obj0 = 0 ;
19818 PyObject * obj1 = 0 ;
19819 PyObject * obj2 = 0 ;
19820 PyObject * obj3 = 0 ;
19821 char *kwnames[] = {
19822 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19823 };
19824
19825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19826 {
19827 arg1 = (int)(SWIG_As_int(obj0));
19828 if (SWIG_arg_fail(1)) SWIG_fail;
19829 }
19830 if (obj1) {
19831 {
19832 arg2 = (int)(SWIG_As_int(obj1));
19833 if (SWIG_arg_fail(2)) SWIG_fail;
19834 }
19835 }
19836 if (obj2) {
19837 {
19838 arg3 = (int)(SWIG_As_int(obj2));
19839 if (SWIG_arg_fail(3)) SWIG_fail;
19840 }
19841 }
19842 if (obj3) {
19843 {
19844 arg4 = (int)(SWIG_As_int(obj3));
19845 if (SWIG_arg_fail(4)) SWIG_fail;
19846 }
19847 }
19848 {
19849 PyThreadState* __tstate = wxPyBeginAllowThreads();
19850 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19851
19852 wxPyEndAllowThreads(__tstate);
19853 if (PyErr_Occurred()) SWIG_fail;
19854 }
19855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19856 return resultobj;
19857 fail:
19858 return NULL;
19859 }
19860
19861
19862 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19863 PyObject *resultobj;
19864 int arg1 ;
19865 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19866 int arg3 = (int) wxDateTime::Inv_Year ;
19867 int arg4 = (int) 0 ;
19868 int arg5 = (int) 0 ;
19869 int arg6 = (int) 0 ;
19870 int arg7 = (int) 0 ;
19871 wxDateTime *result;
19872 PyObject * obj0 = 0 ;
19873 PyObject * obj1 = 0 ;
19874 PyObject * obj2 = 0 ;
19875 PyObject * obj3 = 0 ;
19876 PyObject * obj4 = 0 ;
19877 PyObject * obj5 = 0 ;
19878 PyObject * obj6 = 0 ;
19879 char *kwnames[] = {
19880 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19881 };
19882
19883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19884 {
19885 arg1 = (int)(SWIG_As_int(obj0));
19886 if (SWIG_arg_fail(1)) SWIG_fail;
19887 }
19888 if (obj1) {
19889 {
19890 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19891 if (SWIG_arg_fail(2)) SWIG_fail;
19892 }
19893 }
19894 if (obj2) {
19895 {
19896 arg3 = (int)(SWIG_As_int(obj2));
19897 if (SWIG_arg_fail(3)) SWIG_fail;
19898 }
19899 }
19900 if (obj3) {
19901 {
19902 arg4 = (int)(SWIG_As_int(obj3));
19903 if (SWIG_arg_fail(4)) SWIG_fail;
19904 }
19905 }
19906 if (obj4) {
19907 {
19908 arg5 = (int)(SWIG_As_int(obj4));
19909 if (SWIG_arg_fail(5)) SWIG_fail;
19910 }
19911 }
19912 if (obj5) {
19913 {
19914 arg6 = (int)(SWIG_As_int(obj5));
19915 if (SWIG_arg_fail(6)) SWIG_fail;
19916 }
19917 }
19918 if (obj6) {
19919 {
19920 arg7 = (int)(SWIG_As_int(obj6));
19921 if (SWIG_arg_fail(7)) SWIG_fail;
19922 }
19923 }
19924 {
19925 PyThreadState* __tstate = wxPyBeginAllowThreads();
19926 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19927
19928 wxPyEndAllowThreads(__tstate);
19929 if (PyErr_Occurred()) SWIG_fail;
19930 }
19931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19932 return resultobj;
19933 fail:
19934 return NULL;
19935 }
19936
19937
19938 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19939 PyObject *resultobj;
19940 wxDateTime *arg1 = (wxDateTime *) 0 ;
19941 PyObject * obj0 = 0 ;
19942 char *kwnames[] = {
19943 (char *) "self", NULL
19944 };
19945
19946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19948 if (SWIG_arg_fail(1)) SWIG_fail;
19949 {
19950 PyThreadState* __tstate = wxPyBeginAllowThreads();
19951 delete arg1;
19952
19953 wxPyEndAllowThreads(__tstate);
19954 if (PyErr_Occurred()) SWIG_fail;
19955 }
19956 Py_INCREF(Py_None); resultobj = Py_None;
19957 return resultobj;
19958 fail:
19959 return NULL;
19960 }
19961
19962
19963 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19964 PyObject *resultobj;
19965 wxDateTime *arg1 = (wxDateTime *) 0 ;
19966 wxDateTime *result;
19967 PyObject * obj0 = 0 ;
19968 char *kwnames[] = {
19969 (char *) "self", NULL
19970 };
19971
19972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19974 if (SWIG_arg_fail(1)) SWIG_fail;
19975 {
19976 PyThreadState* __tstate = wxPyBeginAllowThreads();
19977 {
19978 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19979 result = (wxDateTime *) &_result_ref;
19980 }
19981
19982 wxPyEndAllowThreads(__tstate);
19983 if (PyErr_Occurred()) SWIG_fail;
19984 }
19985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19986 return resultobj;
19987 fail:
19988 return NULL;
19989 }
19990
19991
19992 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19993 PyObject *resultobj;
19994 wxDateTime *arg1 = (wxDateTime *) 0 ;
19995 time_t arg2 ;
19996 wxDateTime *result;
19997 PyObject * obj0 = 0 ;
19998 PyObject * obj1 = 0 ;
19999 char *kwnames[] = {
20000 (char *) "self",(char *) "timet", NULL
20001 };
20002
20003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
20004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20005 if (SWIG_arg_fail(1)) SWIG_fail;
20006 {
20007 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
20008 if (SWIG_arg_fail(2)) SWIG_fail;
20009 }
20010 {
20011 PyThreadState* __tstate = wxPyBeginAllowThreads();
20012 {
20013 wxDateTime &_result_ref = (arg1)->Set(arg2);
20014 result = (wxDateTime *) &_result_ref;
20015 }
20016
20017 wxPyEndAllowThreads(__tstate);
20018 if (PyErr_Occurred()) SWIG_fail;
20019 }
20020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20021 return resultobj;
20022 fail:
20023 return NULL;
20024 }
20025
20026
20027 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20028 PyObject *resultobj;
20029 wxDateTime *arg1 = (wxDateTime *) 0 ;
20030 double arg2 ;
20031 wxDateTime *result;
20032 PyObject * obj0 = 0 ;
20033 PyObject * obj1 = 0 ;
20034 char *kwnames[] = {
20035 (char *) "self",(char *) "jdn", NULL
20036 };
20037
20038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
20039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20040 if (SWIG_arg_fail(1)) SWIG_fail;
20041 {
20042 arg2 = (double)(SWIG_As_double(obj1));
20043 if (SWIG_arg_fail(2)) SWIG_fail;
20044 }
20045 {
20046 PyThreadState* __tstate = wxPyBeginAllowThreads();
20047 {
20048 wxDateTime &_result_ref = (arg1)->Set(arg2);
20049 result = (wxDateTime *) &_result_ref;
20050 }
20051
20052 wxPyEndAllowThreads(__tstate);
20053 if (PyErr_Occurred()) SWIG_fail;
20054 }
20055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20056 return resultobj;
20057 fail:
20058 return NULL;
20059 }
20060
20061
20062 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20063 PyObject *resultobj;
20064 wxDateTime *arg1 = (wxDateTime *) 0 ;
20065 int arg2 ;
20066 int arg3 = (int) 0 ;
20067 int arg4 = (int) 0 ;
20068 int arg5 = (int) 0 ;
20069 wxDateTime *result;
20070 PyObject * obj0 = 0 ;
20071 PyObject * obj1 = 0 ;
20072 PyObject * obj2 = 0 ;
20073 PyObject * obj3 = 0 ;
20074 PyObject * obj4 = 0 ;
20075 char *kwnames[] = {
20076 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20077 };
20078
20079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20081 if (SWIG_arg_fail(1)) SWIG_fail;
20082 {
20083 arg2 = (int)(SWIG_As_int(obj1));
20084 if (SWIG_arg_fail(2)) SWIG_fail;
20085 }
20086 if (obj2) {
20087 {
20088 arg3 = (int)(SWIG_As_int(obj2));
20089 if (SWIG_arg_fail(3)) SWIG_fail;
20090 }
20091 }
20092 if (obj3) {
20093 {
20094 arg4 = (int)(SWIG_As_int(obj3));
20095 if (SWIG_arg_fail(4)) SWIG_fail;
20096 }
20097 }
20098 if (obj4) {
20099 {
20100 arg5 = (int)(SWIG_As_int(obj4));
20101 if (SWIG_arg_fail(5)) SWIG_fail;
20102 }
20103 }
20104 {
20105 PyThreadState* __tstate = wxPyBeginAllowThreads();
20106 {
20107 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20108 result = (wxDateTime *) &_result_ref;
20109 }
20110
20111 wxPyEndAllowThreads(__tstate);
20112 if (PyErr_Occurred()) SWIG_fail;
20113 }
20114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20115 return resultobj;
20116 fail:
20117 return NULL;
20118 }
20119
20120
20121 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20122 PyObject *resultobj;
20123 wxDateTime *arg1 = (wxDateTime *) 0 ;
20124 int arg2 ;
20125 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20126 int arg4 = (int) wxDateTime::Inv_Year ;
20127 int arg5 = (int) 0 ;
20128 int arg6 = (int) 0 ;
20129 int arg7 = (int) 0 ;
20130 int arg8 = (int) 0 ;
20131 wxDateTime *result;
20132 PyObject * obj0 = 0 ;
20133 PyObject * obj1 = 0 ;
20134 PyObject * obj2 = 0 ;
20135 PyObject * obj3 = 0 ;
20136 PyObject * obj4 = 0 ;
20137 PyObject * obj5 = 0 ;
20138 PyObject * obj6 = 0 ;
20139 PyObject * obj7 = 0 ;
20140 char *kwnames[] = {
20141 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20142 };
20143
20144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20146 if (SWIG_arg_fail(1)) SWIG_fail;
20147 {
20148 arg2 = (int)(SWIG_As_int(obj1));
20149 if (SWIG_arg_fail(2)) SWIG_fail;
20150 }
20151 if (obj2) {
20152 {
20153 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20154 if (SWIG_arg_fail(3)) SWIG_fail;
20155 }
20156 }
20157 if (obj3) {
20158 {
20159 arg4 = (int)(SWIG_As_int(obj3));
20160 if (SWIG_arg_fail(4)) SWIG_fail;
20161 }
20162 }
20163 if (obj4) {
20164 {
20165 arg5 = (int)(SWIG_As_int(obj4));
20166 if (SWIG_arg_fail(5)) SWIG_fail;
20167 }
20168 }
20169 if (obj5) {
20170 {
20171 arg6 = (int)(SWIG_As_int(obj5));
20172 if (SWIG_arg_fail(6)) SWIG_fail;
20173 }
20174 }
20175 if (obj6) {
20176 {
20177 arg7 = (int)(SWIG_As_int(obj6));
20178 if (SWIG_arg_fail(7)) SWIG_fail;
20179 }
20180 }
20181 if (obj7) {
20182 {
20183 arg8 = (int)(SWIG_As_int(obj7));
20184 if (SWIG_arg_fail(8)) SWIG_fail;
20185 }
20186 }
20187 {
20188 PyThreadState* __tstate = wxPyBeginAllowThreads();
20189 {
20190 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20191 result = (wxDateTime *) &_result_ref;
20192 }
20193
20194 wxPyEndAllowThreads(__tstate);
20195 if (PyErr_Occurred()) SWIG_fail;
20196 }
20197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20198 return resultobj;
20199 fail:
20200 return NULL;
20201 }
20202
20203
20204 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20205 PyObject *resultobj;
20206 wxDateTime *arg1 = (wxDateTime *) 0 ;
20207 wxDateTime *result;
20208 PyObject * obj0 = 0 ;
20209 char *kwnames[] = {
20210 (char *) "self", NULL
20211 };
20212
20213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20215 if (SWIG_arg_fail(1)) SWIG_fail;
20216 {
20217 PyThreadState* __tstate = wxPyBeginAllowThreads();
20218 {
20219 wxDateTime &_result_ref = (arg1)->ResetTime();
20220 result = (wxDateTime *) &_result_ref;
20221 }
20222
20223 wxPyEndAllowThreads(__tstate);
20224 if (PyErr_Occurred()) SWIG_fail;
20225 }
20226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20227 return resultobj;
20228 fail:
20229 return NULL;
20230 }
20231
20232
20233 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20234 PyObject *resultobj;
20235 wxDateTime *arg1 = (wxDateTime *) 0 ;
20236 int arg2 ;
20237 wxDateTime *result;
20238 PyObject * obj0 = 0 ;
20239 PyObject * obj1 = 0 ;
20240 char *kwnames[] = {
20241 (char *) "self",(char *) "year", NULL
20242 };
20243
20244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20246 if (SWIG_arg_fail(1)) SWIG_fail;
20247 {
20248 arg2 = (int)(SWIG_As_int(obj1));
20249 if (SWIG_arg_fail(2)) SWIG_fail;
20250 }
20251 {
20252 PyThreadState* __tstate = wxPyBeginAllowThreads();
20253 {
20254 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20255 result = (wxDateTime *) &_result_ref;
20256 }
20257
20258 wxPyEndAllowThreads(__tstate);
20259 if (PyErr_Occurred()) SWIG_fail;
20260 }
20261 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20262 return resultobj;
20263 fail:
20264 return NULL;
20265 }
20266
20267
20268 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20269 PyObject *resultobj;
20270 wxDateTime *arg1 = (wxDateTime *) 0 ;
20271 wxDateTime::Month arg2 ;
20272 wxDateTime *result;
20273 PyObject * obj0 = 0 ;
20274 PyObject * obj1 = 0 ;
20275 char *kwnames[] = {
20276 (char *) "self",(char *) "month", NULL
20277 };
20278
20279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20281 if (SWIG_arg_fail(1)) SWIG_fail;
20282 {
20283 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20284 if (SWIG_arg_fail(2)) SWIG_fail;
20285 }
20286 {
20287 PyThreadState* __tstate = wxPyBeginAllowThreads();
20288 {
20289 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20290 result = (wxDateTime *) &_result_ref;
20291 }
20292
20293 wxPyEndAllowThreads(__tstate);
20294 if (PyErr_Occurred()) SWIG_fail;
20295 }
20296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20297 return resultobj;
20298 fail:
20299 return NULL;
20300 }
20301
20302
20303 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20304 PyObject *resultobj;
20305 wxDateTime *arg1 = (wxDateTime *) 0 ;
20306 int arg2 ;
20307 wxDateTime *result;
20308 PyObject * obj0 = 0 ;
20309 PyObject * obj1 = 0 ;
20310 char *kwnames[] = {
20311 (char *) "self",(char *) "day", NULL
20312 };
20313
20314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20316 if (SWIG_arg_fail(1)) SWIG_fail;
20317 {
20318 arg2 = (int)(SWIG_As_int(obj1));
20319 if (SWIG_arg_fail(2)) SWIG_fail;
20320 }
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 {
20324 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20325 result = (wxDateTime *) &_result_ref;
20326 }
20327
20328 wxPyEndAllowThreads(__tstate);
20329 if (PyErr_Occurred()) SWIG_fail;
20330 }
20331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20332 return resultobj;
20333 fail:
20334 return NULL;
20335 }
20336
20337
20338 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20339 PyObject *resultobj;
20340 wxDateTime *arg1 = (wxDateTime *) 0 ;
20341 int arg2 ;
20342 wxDateTime *result;
20343 PyObject * obj0 = 0 ;
20344 PyObject * obj1 = 0 ;
20345 char *kwnames[] = {
20346 (char *) "self",(char *) "hour", NULL
20347 };
20348
20349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20351 if (SWIG_arg_fail(1)) SWIG_fail;
20352 {
20353 arg2 = (int)(SWIG_As_int(obj1));
20354 if (SWIG_arg_fail(2)) SWIG_fail;
20355 }
20356 {
20357 PyThreadState* __tstate = wxPyBeginAllowThreads();
20358 {
20359 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20360 result = (wxDateTime *) &_result_ref;
20361 }
20362
20363 wxPyEndAllowThreads(__tstate);
20364 if (PyErr_Occurred()) SWIG_fail;
20365 }
20366 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20367 return resultobj;
20368 fail:
20369 return NULL;
20370 }
20371
20372
20373 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20374 PyObject *resultobj;
20375 wxDateTime *arg1 = (wxDateTime *) 0 ;
20376 int arg2 ;
20377 wxDateTime *result;
20378 PyObject * obj0 = 0 ;
20379 PyObject * obj1 = 0 ;
20380 char *kwnames[] = {
20381 (char *) "self",(char *) "minute", NULL
20382 };
20383
20384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20386 if (SWIG_arg_fail(1)) SWIG_fail;
20387 {
20388 arg2 = (int)(SWIG_As_int(obj1));
20389 if (SWIG_arg_fail(2)) SWIG_fail;
20390 }
20391 {
20392 PyThreadState* __tstate = wxPyBeginAllowThreads();
20393 {
20394 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20395 result = (wxDateTime *) &_result_ref;
20396 }
20397
20398 wxPyEndAllowThreads(__tstate);
20399 if (PyErr_Occurred()) SWIG_fail;
20400 }
20401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20402 return resultobj;
20403 fail:
20404 return NULL;
20405 }
20406
20407
20408 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20409 PyObject *resultobj;
20410 wxDateTime *arg1 = (wxDateTime *) 0 ;
20411 int arg2 ;
20412 wxDateTime *result;
20413 PyObject * obj0 = 0 ;
20414 PyObject * obj1 = 0 ;
20415 char *kwnames[] = {
20416 (char *) "self",(char *) "second", NULL
20417 };
20418
20419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20421 if (SWIG_arg_fail(1)) SWIG_fail;
20422 {
20423 arg2 = (int)(SWIG_As_int(obj1));
20424 if (SWIG_arg_fail(2)) SWIG_fail;
20425 }
20426 {
20427 PyThreadState* __tstate = wxPyBeginAllowThreads();
20428 {
20429 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20430 result = (wxDateTime *) &_result_ref;
20431 }
20432
20433 wxPyEndAllowThreads(__tstate);
20434 if (PyErr_Occurred()) SWIG_fail;
20435 }
20436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20437 return resultobj;
20438 fail:
20439 return NULL;
20440 }
20441
20442
20443 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20444 PyObject *resultobj;
20445 wxDateTime *arg1 = (wxDateTime *) 0 ;
20446 int arg2 ;
20447 wxDateTime *result;
20448 PyObject * obj0 = 0 ;
20449 PyObject * obj1 = 0 ;
20450 char *kwnames[] = {
20451 (char *) "self",(char *) "millisecond", NULL
20452 };
20453
20454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20456 if (SWIG_arg_fail(1)) SWIG_fail;
20457 {
20458 arg2 = (int)(SWIG_As_int(obj1));
20459 if (SWIG_arg_fail(2)) SWIG_fail;
20460 }
20461 {
20462 PyThreadState* __tstate = wxPyBeginAllowThreads();
20463 {
20464 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20465 result = (wxDateTime *) &_result_ref;
20466 }
20467
20468 wxPyEndAllowThreads(__tstate);
20469 if (PyErr_Occurred()) SWIG_fail;
20470 }
20471 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20472 return resultobj;
20473 fail:
20474 return NULL;
20475 }
20476
20477
20478 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20479 PyObject *resultobj;
20480 wxDateTime *arg1 = (wxDateTime *) 0 ;
20481 wxDateTime::WeekDay arg2 ;
20482 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20483 wxDateTime *result;
20484 PyObject * obj0 = 0 ;
20485 PyObject * obj1 = 0 ;
20486 PyObject * obj2 = 0 ;
20487 char *kwnames[] = {
20488 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20489 };
20490
20491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20493 if (SWIG_arg_fail(1)) SWIG_fail;
20494 {
20495 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20496 if (SWIG_arg_fail(2)) SWIG_fail;
20497 }
20498 if (obj2) {
20499 {
20500 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20501 if (SWIG_arg_fail(3)) SWIG_fail;
20502 }
20503 }
20504 {
20505 PyThreadState* __tstate = wxPyBeginAllowThreads();
20506 {
20507 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20508 result = (wxDateTime *) &_result_ref;
20509 }
20510
20511 wxPyEndAllowThreads(__tstate);
20512 if (PyErr_Occurred()) SWIG_fail;
20513 }
20514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20515 return resultobj;
20516 fail:
20517 return NULL;
20518 }
20519
20520
20521 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20522 PyObject *resultobj;
20523 wxDateTime *arg1 = (wxDateTime *) 0 ;
20524 wxDateTime::WeekDay arg2 ;
20525 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20526 wxDateTime result;
20527 PyObject * obj0 = 0 ;
20528 PyObject * obj1 = 0 ;
20529 PyObject * obj2 = 0 ;
20530 char *kwnames[] = {
20531 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20532 };
20533
20534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20536 if (SWIG_arg_fail(1)) SWIG_fail;
20537 {
20538 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20539 if (SWIG_arg_fail(2)) SWIG_fail;
20540 }
20541 if (obj2) {
20542 {
20543 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20544 if (SWIG_arg_fail(3)) SWIG_fail;
20545 }
20546 }
20547 {
20548 PyThreadState* __tstate = wxPyBeginAllowThreads();
20549 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20550
20551 wxPyEndAllowThreads(__tstate);
20552 if (PyErr_Occurred()) SWIG_fail;
20553 }
20554 {
20555 wxDateTime * resultptr;
20556 resultptr = new wxDateTime((wxDateTime &)(result));
20557 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20558 }
20559 return resultobj;
20560 fail:
20561 return NULL;
20562 }
20563
20564
20565 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20566 PyObject *resultobj;
20567 wxDateTime *arg1 = (wxDateTime *) 0 ;
20568 wxDateTime::WeekDay arg2 ;
20569 wxDateTime *result;
20570 PyObject * obj0 = 0 ;
20571 PyObject * obj1 = 0 ;
20572 char *kwnames[] = {
20573 (char *) "self",(char *) "weekday", NULL
20574 };
20575
20576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20578 if (SWIG_arg_fail(1)) SWIG_fail;
20579 {
20580 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20581 if (SWIG_arg_fail(2)) SWIG_fail;
20582 }
20583 {
20584 PyThreadState* __tstate = wxPyBeginAllowThreads();
20585 {
20586 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20587 result = (wxDateTime *) &_result_ref;
20588 }
20589
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20594 return resultobj;
20595 fail:
20596 return NULL;
20597 }
20598
20599
20600 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20601 PyObject *resultobj;
20602 wxDateTime *arg1 = (wxDateTime *) 0 ;
20603 wxDateTime::WeekDay arg2 ;
20604 wxDateTime result;
20605 PyObject * obj0 = 0 ;
20606 PyObject * obj1 = 0 ;
20607 char *kwnames[] = {
20608 (char *) "self",(char *) "weekday", NULL
20609 };
20610
20611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20613 if (SWIG_arg_fail(1)) SWIG_fail;
20614 {
20615 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20616 if (SWIG_arg_fail(2)) SWIG_fail;
20617 }
20618 {
20619 PyThreadState* __tstate = wxPyBeginAllowThreads();
20620 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20621
20622 wxPyEndAllowThreads(__tstate);
20623 if (PyErr_Occurred()) SWIG_fail;
20624 }
20625 {
20626 wxDateTime * resultptr;
20627 resultptr = new wxDateTime((wxDateTime &)(result));
20628 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20629 }
20630 return resultobj;
20631 fail:
20632 return NULL;
20633 }
20634
20635
20636 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20637 PyObject *resultobj;
20638 wxDateTime *arg1 = (wxDateTime *) 0 ;
20639 wxDateTime::WeekDay arg2 ;
20640 wxDateTime *result;
20641 PyObject * obj0 = 0 ;
20642 PyObject * obj1 = 0 ;
20643 char *kwnames[] = {
20644 (char *) "self",(char *) "weekday", NULL
20645 };
20646
20647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20649 if (SWIG_arg_fail(1)) SWIG_fail;
20650 {
20651 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20652 if (SWIG_arg_fail(2)) SWIG_fail;
20653 }
20654 {
20655 PyThreadState* __tstate = wxPyBeginAllowThreads();
20656 {
20657 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20658 result = (wxDateTime *) &_result_ref;
20659 }
20660
20661 wxPyEndAllowThreads(__tstate);
20662 if (PyErr_Occurred()) SWIG_fail;
20663 }
20664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20665 return resultobj;
20666 fail:
20667 return NULL;
20668 }
20669
20670
20671 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20672 PyObject *resultobj;
20673 wxDateTime *arg1 = (wxDateTime *) 0 ;
20674 wxDateTime::WeekDay arg2 ;
20675 wxDateTime result;
20676 PyObject * obj0 = 0 ;
20677 PyObject * obj1 = 0 ;
20678 char *kwnames[] = {
20679 (char *) "self",(char *) "weekday", NULL
20680 };
20681
20682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20684 if (SWIG_arg_fail(1)) SWIG_fail;
20685 {
20686 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20687 if (SWIG_arg_fail(2)) SWIG_fail;
20688 }
20689 {
20690 PyThreadState* __tstate = wxPyBeginAllowThreads();
20691 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20692
20693 wxPyEndAllowThreads(__tstate);
20694 if (PyErr_Occurred()) SWIG_fail;
20695 }
20696 {
20697 wxDateTime * resultptr;
20698 resultptr = new wxDateTime((wxDateTime &)(result));
20699 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20700 }
20701 return resultobj;
20702 fail:
20703 return NULL;
20704 }
20705
20706
20707 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20708 PyObject *resultobj;
20709 wxDateTime *arg1 = (wxDateTime *) 0 ;
20710 wxDateTime::WeekDay arg2 ;
20711 int arg3 = (int) 1 ;
20712 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20713 int arg5 = (int) wxDateTime::Inv_Year ;
20714 bool result;
20715 PyObject * obj0 = 0 ;
20716 PyObject * obj1 = 0 ;
20717 PyObject * obj2 = 0 ;
20718 PyObject * obj3 = 0 ;
20719 PyObject * obj4 = 0 ;
20720 char *kwnames[] = {
20721 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20722 };
20723
20724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20726 if (SWIG_arg_fail(1)) SWIG_fail;
20727 {
20728 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20729 if (SWIG_arg_fail(2)) SWIG_fail;
20730 }
20731 if (obj2) {
20732 {
20733 arg3 = (int)(SWIG_As_int(obj2));
20734 if (SWIG_arg_fail(3)) SWIG_fail;
20735 }
20736 }
20737 if (obj3) {
20738 {
20739 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20740 if (SWIG_arg_fail(4)) SWIG_fail;
20741 }
20742 }
20743 if (obj4) {
20744 {
20745 arg5 = (int)(SWIG_As_int(obj4));
20746 if (SWIG_arg_fail(5)) SWIG_fail;
20747 }
20748 }
20749 {
20750 PyThreadState* __tstate = wxPyBeginAllowThreads();
20751 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20752
20753 wxPyEndAllowThreads(__tstate);
20754 if (PyErr_Occurred()) SWIG_fail;
20755 }
20756 {
20757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20758 }
20759 return resultobj;
20760 fail:
20761 return NULL;
20762 }
20763
20764
20765 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20766 PyObject *resultobj;
20767 wxDateTime *arg1 = (wxDateTime *) 0 ;
20768 wxDateTime::WeekDay arg2 ;
20769 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20770 int arg4 = (int) wxDateTime::Inv_Year ;
20771 bool result;
20772 PyObject * obj0 = 0 ;
20773 PyObject * obj1 = 0 ;
20774 PyObject * obj2 = 0 ;
20775 PyObject * obj3 = 0 ;
20776 char *kwnames[] = {
20777 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20778 };
20779
20780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20782 if (SWIG_arg_fail(1)) SWIG_fail;
20783 {
20784 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20785 if (SWIG_arg_fail(2)) SWIG_fail;
20786 }
20787 if (obj2) {
20788 {
20789 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20790 if (SWIG_arg_fail(3)) SWIG_fail;
20791 }
20792 }
20793 if (obj3) {
20794 {
20795 arg4 = (int)(SWIG_As_int(obj3));
20796 if (SWIG_arg_fail(4)) SWIG_fail;
20797 }
20798 }
20799 {
20800 PyThreadState* __tstate = wxPyBeginAllowThreads();
20801 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20802
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 {
20807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20808 }
20809 return resultobj;
20810 fail:
20811 return NULL;
20812 }
20813
20814
20815 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20816 PyObject *resultobj;
20817 wxDateTime *arg1 = (wxDateTime *) 0 ;
20818 wxDateTime::WeekDay arg2 ;
20819 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20820 int arg4 = (int) wxDateTime::Inv_Year ;
20821 wxDateTime result;
20822 PyObject * obj0 = 0 ;
20823 PyObject * obj1 = 0 ;
20824 PyObject * obj2 = 0 ;
20825 PyObject * obj3 = 0 ;
20826 char *kwnames[] = {
20827 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20828 };
20829
20830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20832 if (SWIG_arg_fail(1)) SWIG_fail;
20833 {
20834 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20835 if (SWIG_arg_fail(2)) SWIG_fail;
20836 }
20837 if (obj2) {
20838 {
20839 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20840 if (SWIG_arg_fail(3)) SWIG_fail;
20841 }
20842 }
20843 if (obj3) {
20844 {
20845 arg4 = (int)(SWIG_As_int(obj3));
20846 if (SWIG_arg_fail(4)) SWIG_fail;
20847 }
20848 }
20849 {
20850 PyThreadState* __tstate = wxPyBeginAllowThreads();
20851 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20852
20853 wxPyEndAllowThreads(__tstate);
20854 if (PyErr_Occurred()) SWIG_fail;
20855 }
20856 {
20857 wxDateTime * resultptr;
20858 resultptr = new wxDateTime((wxDateTime &)(result));
20859 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20860 }
20861 return resultobj;
20862 fail:
20863 return NULL;
20864 }
20865
20866
20867 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20868 PyObject *resultobj;
20869 wxDateTime *arg1 = (wxDateTime *) 0 ;
20870 int arg2 ;
20871 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20872 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20873 bool result;
20874 PyObject * obj0 = 0 ;
20875 PyObject * obj1 = 0 ;
20876 PyObject * obj2 = 0 ;
20877 PyObject * obj3 = 0 ;
20878 char *kwnames[] = {
20879 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20880 };
20881
20882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20884 if (SWIG_arg_fail(1)) SWIG_fail;
20885 {
20886 arg2 = (int)(SWIG_As_int(obj1));
20887 if (SWIG_arg_fail(2)) SWIG_fail;
20888 }
20889 if (obj2) {
20890 {
20891 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20892 if (SWIG_arg_fail(3)) SWIG_fail;
20893 }
20894 }
20895 if (obj3) {
20896 {
20897 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20898 if (SWIG_arg_fail(4)) SWIG_fail;
20899 }
20900 }
20901 {
20902 PyThreadState* __tstate = wxPyBeginAllowThreads();
20903 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20904
20905 wxPyEndAllowThreads(__tstate);
20906 if (PyErr_Occurred()) SWIG_fail;
20907 }
20908 {
20909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20910 }
20911 return resultobj;
20912 fail:
20913 return NULL;
20914 }
20915
20916
20917 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20918 PyObject *resultobj;
20919 wxDateTime *arg1 = (wxDateTime *) 0 ;
20920 int arg2 ;
20921 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20922 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20923 wxDateTime result;
20924 PyObject * obj0 = 0 ;
20925 PyObject * obj1 = 0 ;
20926 PyObject * obj2 = 0 ;
20927 PyObject * obj3 = 0 ;
20928 char *kwnames[] = {
20929 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20930 };
20931
20932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20934 if (SWIG_arg_fail(1)) SWIG_fail;
20935 {
20936 arg2 = (int)(SWIG_As_int(obj1));
20937 if (SWIG_arg_fail(2)) SWIG_fail;
20938 }
20939 if (obj2) {
20940 {
20941 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20942 if (SWIG_arg_fail(3)) SWIG_fail;
20943 }
20944 }
20945 if (obj3) {
20946 {
20947 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20948 if (SWIG_arg_fail(4)) SWIG_fail;
20949 }
20950 }
20951 {
20952 PyThreadState* __tstate = wxPyBeginAllowThreads();
20953 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20954
20955 wxPyEndAllowThreads(__tstate);
20956 if (PyErr_Occurred()) SWIG_fail;
20957 }
20958 {
20959 wxDateTime * resultptr;
20960 resultptr = new wxDateTime((wxDateTime &)(result));
20961 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20962 }
20963 return resultobj;
20964 fail:
20965 return NULL;
20966 }
20967
20968
20969 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20970 PyObject *resultobj;
20971 int arg1 ;
20972 int arg2 ;
20973 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20974 wxDateTime result;
20975 PyObject * obj0 = 0 ;
20976 PyObject * obj1 = 0 ;
20977 PyObject * obj2 = 0 ;
20978 char *kwnames[] = {
20979 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20980 };
20981
20982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20983 {
20984 arg1 = (int)(SWIG_As_int(obj0));
20985 if (SWIG_arg_fail(1)) SWIG_fail;
20986 }
20987 {
20988 arg2 = (int)(SWIG_As_int(obj1));
20989 if (SWIG_arg_fail(2)) SWIG_fail;
20990 }
20991 if (obj2) {
20992 {
20993 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20994 if (SWIG_arg_fail(3)) SWIG_fail;
20995 }
20996 }
20997 {
20998 PyThreadState* __tstate = wxPyBeginAllowThreads();
20999 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
21000
21001 wxPyEndAllowThreads(__tstate);
21002 if (PyErr_Occurred()) SWIG_fail;
21003 }
21004 {
21005 wxDateTime * resultptr;
21006 resultptr = new wxDateTime((wxDateTime &)(result));
21007 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21008 }
21009 return resultobj;
21010 fail:
21011 return NULL;
21012 }
21013
21014
21015 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21016 PyObject *resultobj;
21017 wxDateTime *arg1 = (wxDateTime *) 0 ;
21018 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21019 int arg3 = (int) wxDateTime::Inv_Year ;
21020 wxDateTime *result;
21021 PyObject * obj0 = 0 ;
21022 PyObject * obj1 = 0 ;
21023 PyObject * obj2 = 0 ;
21024 char *kwnames[] = {
21025 (char *) "self",(char *) "month",(char *) "year", NULL
21026 };
21027
21028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21030 if (SWIG_arg_fail(1)) SWIG_fail;
21031 if (obj1) {
21032 {
21033 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21034 if (SWIG_arg_fail(2)) SWIG_fail;
21035 }
21036 }
21037 if (obj2) {
21038 {
21039 arg3 = (int)(SWIG_As_int(obj2));
21040 if (SWIG_arg_fail(3)) SWIG_fail;
21041 }
21042 }
21043 {
21044 PyThreadState* __tstate = wxPyBeginAllowThreads();
21045 {
21046 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
21047 result = (wxDateTime *) &_result_ref;
21048 }
21049
21050 wxPyEndAllowThreads(__tstate);
21051 if (PyErr_Occurred()) SWIG_fail;
21052 }
21053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21061 PyObject *resultobj;
21062 wxDateTime *arg1 = (wxDateTime *) 0 ;
21063 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21064 int arg3 = (int) wxDateTime::Inv_Year ;
21065 wxDateTime result;
21066 PyObject * obj0 = 0 ;
21067 PyObject * obj1 = 0 ;
21068 PyObject * obj2 = 0 ;
21069 char *kwnames[] = {
21070 (char *) "self",(char *) "month",(char *) "year", NULL
21071 };
21072
21073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21075 if (SWIG_arg_fail(1)) SWIG_fail;
21076 if (obj1) {
21077 {
21078 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21079 if (SWIG_arg_fail(2)) SWIG_fail;
21080 }
21081 }
21082 if (obj2) {
21083 {
21084 arg3 = (int)(SWIG_As_int(obj2));
21085 if (SWIG_arg_fail(3)) SWIG_fail;
21086 }
21087 }
21088 {
21089 PyThreadState* __tstate = wxPyBeginAllowThreads();
21090 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21091
21092 wxPyEndAllowThreads(__tstate);
21093 if (PyErr_Occurred()) SWIG_fail;
21094 }
21095 {
21096 wxDateTime * resultptr;
21097 resultptr = new wxDateTime((wxDateTime &)(result));
21098 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21099 }
21100 return resultobj;
21101 fail:
21102 return NULL;
21103 }
21104
21105
21106 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21107 PyObject *resultobj;
21108 wxDateTime *arg1 = (wxDateTime *) 0 ;
21109 int arg2 ;
21110 wxDateTime *result;
21111 PyObject * obj0 = 0 ;
21112 PyObject * obj1 = 0 ;
21113 char *kwnames[] = {
21114 (char *) "self",(char *) "yday", NULL
21115 };
21116
21117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21119 if (SWIG_arg_fail(1)) SWIG_fail;
21120 {
21121 arg2 = (int)(SWIG_As_int(obj1));
21122 if (SWIG_arg_fail(2)) SWIG_fail;
21123 }
21124 {
21125 PyThreadState* __tstate = wxPyBeginAllowThreads();
21126 {
21127 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21128 result = (wxDateTime *) &_result_ref;
21129 }
21130
21131 wxPyEndAllowThreads(__tstate);
21132 if (PyErr_Occurred()) SWIG_fail;
21133 }
21134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21135 return resultobj;
21136 fail:
21137 return NULL;
21138 }
21139
21140
21141 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21142 PyObject *resultobj;
21143 wxDateTime *arg1 = (wxDateTime *) 0 ;
21144 int arg2 ;
21145 wxDateTime result;
21146 PyObject * obj0 = 0 ;
21147 PyObject * obj1 = 0 ;
21148 char *kwnames[] = {
21149 (char *) "self",(char *) "yday", NULL
21150 };
21151
21152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21154 if (SWIG_arg_fail(1)) SWIG_fail;
21155 {
21156 arg2 = (int)(SWIG_As_int(obj1));
21157 if (SWIG_arg_fail(2)) SWIG_fail;
21158 }
21159 {
21160 PyThreadState* __tstate = wxPyBeginAllowThreads();
21161 result = (arg1)->GetYearDay(arg2);
21162
21163 wxPyEndAllowThreads(__tstate);
21164 if (PyErr_Occurred()) SWIG_fail;
21165 }
21166 {
21167 wxDateTime * resultptr;
21168 resultptr = new wxDateTime((wxDateTime &)(result));
21169 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21170 }
21171 return resultobj;
21172 fail:
21173 return NULL;
21174 }
21175
21176
21177 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21178 PyObject *resultobj;
21179 wxDateTime *arg1 = (wxDateTime *) 0 ;
21180 double result;
21181 PyObject * obj0 = 0 ;
21182 char *kwnames[] = {
21183 (char *) "self", NULL
21184 };
21185
21186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21188 if (SWIG_arg_fail(1)) SWIG_fail;
21189 {
21190 PyThreadState* __tstate = wxPyBeginAllowThreads();
21191 result = (double)(arg1)->GetJulianDayNumber();
21192
21193 wxPyEndAllowThreads(__tstate);
21194 if (PyErr_Occurred()) SWIG_fail;
21195 }
21196 {
21197 resultobj = SWIG_From_double((double)(result));
21198 }
21199 return resultobj;
21200 fail:
21201 return NULL;
21202 }
21203
21204
21205 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21206 PyObject *resultobj;
21207 wxDateTime *arg1 = (wxDateTime *) 0 ;
21208 double result;
21209 PyObject * obj0 = 0 ;
21210 char *kwnames[] = {
21211 (char *) "self", NULL
21212 };
21213
21214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21216 if (SWIG_arg_fail(1)) SWIG_fail;
21217 {
21218 PyThreadState* __tstate = wxPyBeginAllowThreads();
21219 result = (double)(arg1)->GetJDN();
21220
21221 wxPyEndAllowThreads(__tstate);
21222 if (PyErr_Occurred()) SWIG_fail;
21223 }
21224 {
21225 resultobj = SWIG_From_double((double)(result));
21226 }
21227 return resultobj;
21228 fail:
21229 return NULL;
21230 }
21231
21232
21233 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21234 PyObject *resultobj;
21235 wxDateTime *arg1 = (wxDateTime *) 0 ;
21236 double result;
21237 PyObject * obj0 = 0 ;
21238 char *kwnames[] = {
21239 (char *) "self", NULL
21240 };
21241
21242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21244 if (SWIG_arg_fail(1)) SWIG_fail;
21245 {
21246 PyThreadState* __tstate = wxPyBeginAllowThreads();
21247 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21248
21249 wxPyEndAllowThreads(__tstate);
21250 if (PyErr_Occurred()) SWIG_fail;
21251 }
21252 {
21253 resultobj = SWIG_From_double((double)(result));
21254 }
21255 return resultobj;
21256 fail:
21257 return NULL;
21258 }
21259
21260
21261 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21262 PyObject *resultobj;
21263 wxDateTime *arg1 = (wxDateTime *) 0 ;
21264 double result;
21265 PyObject * obj0 = 0 ;
21266 char *kwnames[] = {
21267 (char *) "self", NULL
21268 };
21269
21270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21272 if (SWIG_arg_fail(1)) SWIG_fail;
21273 {
21274 PyThreadState* __tstate = wxPyBeginAllowThreads();
21275 result = (double)(arg1)->GetMJD();
21276
21277 wxPyEndAllowThreads(__tstate);
21278 if (PyErr_Occurred()) SWIG_fail;
21279 }
21280 {
21281 resultobj = SWIG_From_double((double)(result));
21282 }
21283 return resultobj;
21284 fail:
21285 return NULL;
21286 }
21287
21288
21289 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21290 PyObject *resultobj;
21291 wxDateTime *arg1 = (wxDateTime *) 0 ;
21292 double result;
21293 PyObject * obj0 = 0 ;
21294 char *kwnames[] = {
21295 (char *) "self", NULL
21296 };
21297
21298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21300 if (SWIG_arg_fail(1)) SWIG_fail;
21301 {
21302 PyThreadState* __tstate = wxPyBeginAllowThreads();
21303 result = (double)(arg1)->GetRataDie();
21304
21305 wxPyEndAllowThreads(__tstate);
21306 if (PyErr_Occurred()) SWIG_fail;
21307 }
21308 {
21309 resultobj = SWIG_From_double((double)(result));
21310 }
21311 return resultobj;
21312 fail:
21313 return NULL;
21314 }
21315
21316
21317 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21318 PyObject *resultobj;
21319 wxDateTime *arg1 = (wxDateTime *) 0 ;
21320 wxDateTime::TimeZone *arg2 = 0 ;
21321 bool arg3 = (bool) false ;
21322 wxDateTime result;
21323 bool temp2 = false ;
21324 PyObject * obj0 = 0 ;
21325 PyObject * obj1 = 0 ;
21326 PyObject * obj2 = 0 ;
21327 char *kwnames[] = {
21328 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21329 };
21330
21331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) 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 {
21335 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21336 temp2 = true;
21337 }
21338 if (obj2) {
21339 {
21340 arg3 = (bool)(SWIG_As_bool(obj2));
21341 if (SWIG_arg_fail(3)) SWIG_fail;
21342 }
21343 }
21344 {
21345 PyThreadState* __tstate = wxPyBeginAllowThreads();
21346 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21347
21348 wxPyEndAllowThreads(__tstate);
21349 if (PyErr_Occurred()) SWIG_fail;
21350 }
21351 {
21352 wxDateTime * resultptr;
21353 resultptr = new wxDateTime((wxDateTime &)(result));
21354 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21355 }
21356 {
21357 if (temp2) delete arg2;
21358 }
21359 return resultobj;
21360 fail:
21361 {
21362 if (temp2) delete arg2;
21363 }
21364 return NULL;
21365 }
21366
21367
21368 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21369 PyObject *resultobj;
21370 wxDateTime *arg1 = (wxDateTime *) 0 ;
21371 wxDateTime::TimeZone *arg2 = 0 ;
21372 bool arg3 = (bool) false ;
21373 wxDateTime *result;
21374 bool temp2 = false ;
21375 PyObject * obj0 = 0 ;
21376 PyObject * obj1 = 0 ;
21377 PyObject * obj2 = 0 ;
21378 char *kwnames[] = {
21379 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21380 };
21381
21382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21384 if (SWIG_arg_fail(1)) SWIG_fail;
21385 {
21386 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21387 temp2 = true;
21388 }
21389 if (obj2) {
21390 {
21391 arg3 = (bool)(SWIG_As_bool(obj2));
21392 if (SWIG_arg_fail(3)) SWIG_fail;
21393 }
21394 }
21395 {
21396 PyThreadState* __tstate = wxPyBeginAllowThreads();
21397 {
21398 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21399 result = (wxDateTime *) &_result_ref;
21400 }
21401
21402 wxPyEndAllowThreads(__tstate);
21403 if (PyErr_Occurred()) SWIG_fail;
21404 }
21405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21406 {
21407 if (temp2) delete arg2;
21408 }
21409 return resultobj;
21410 fail:
21411 {
21412 if (temp2) delete arg2;
21413 }
21414 return NULL;
21415 }
21416
21417
21418 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21419 PyObject *resultobj;
21420 wxDateTime *arg1 = (wxDateTime *) 0 ;
21421 bool arg2 = (bool) false ;
21422 wxDateTime result;
21423 PyObject * obj0 = 0 ;
21424 PyObject * obj1 = 0 ;
21425 char *kwnames[] = {
21426 (char *) "self",(char *) "noDST", NULL
21427 };
21428
21429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21431 if (SWIG_arg_fail(1)) SWIG_fail;
21432 if (obj1) {
21433 {
21434 arg2 = (bool)(SWIG_As_bool(obj1));
21435 if (SWIG_arg_fail(2)) SWIG_fail;
21436 }
21437 }
21438 {
21439 PyThreadState* __tstate = wxPyBeginAllowThreads();
21440 result = (arg1)->ToGMT(arg2);
21441
21442 wxPyEndAllowThreads(__tstate);
21443 if (PyErr_Occurred()) SWIG_fail;
21444 }
21445 {
21446 wxDateTime * resultptr;
21447 resultptr = new wxDateTime((wxDateTime &)(result));
21448 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21449 }
21450 return resultobj;
21451 fail:
21452 return NULL;
21453 }
21454
21455
21456 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21457 PyObject *resultobj;
21458 wxDateTime *arg1 = (wxDateTime *) 0 ;
21459 bool arg2 = (bool) false ;
21460 wxDateTime *result;
21461 PyObject * obj0 = 0 ;
21462 PyObject * obj1 = 0 ;
21463 char *kwnames[] = {
21464 (char *) "self",(char *) "noDST", NULL
21465 };
21466
21467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21469 if (SWIG_arg_fail(1)) SWIG_fail;
21470 if (obj1) {
21471 {
21472 arg2 = (bool)(SWIG_As_bool(obj1));
21473 if (SWIG_arg_fail(2)) SWIG_fail;
21474 }
21475 }
21476 {
21477 PyThreadState* __tstate = wxPyBeginAllowThreads();
21478 {
21479 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21480 result = (wxDateTime *) &_result_ref;
21481 }
21482
21483 wxPyEndAllowThreads(__tstate);
21484 if (PyErr_Occurred()) SWIG_fail;
21485 }
21486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21487 return resultobj;
21488 fail:
21489 return NULL;
21490 }
21491
21492
21493 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21494 PyObject *resultobj;
21495 wxDateTime *arg1 = (wxDateTime *) 0 ;
21496 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21497 int result;
21498 PyObject * obj0 = 0 ;
21499 PyObject * obj1 = 0 ;
21500 char *kwnames[] = {
21501 (char *) "self",(char *) "country", NULL
21502 };
21503
21504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21506 if (SWIG_arg_fail(1)) SWIG_fail;
21507 if (obj1) {
21508 {
21509 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21510 if (SWIG_arg_fail(2)) SWIG_fail;
21511 }
21512 }
21513 {
21514 PyThreadState* __tstate = wxPyBeginAllowThreads();
21515 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21516
21517 wxPyEndAllowThreads(__tstate);
21518 if (PyErr_Occurred()) SWIG_fail;
21519 }
21520 {
21521 resultobj = SWIG_From_int((int)(result));
21522 }
21523 return resultobj;
21524 fail:
21525 return NULL;
21526 }
21527
21528
21529 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21530 PyObject *resultobj;
21531 wxDateTime *arg1 = (wxDateTime *) 0 ;
21532 bool result;
21533 PyObject * obj0 = 0 ;
21534 char *kwnames[] = {
21535 (char *) "self", NULL
21536 };
21537
21538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21540 if (SWIG_arg_fail(1)) SWIG_fail;
21541 {
21542 PyThreadState* __tstate = wxPyBeginAllowThreads();
21543 result = (bool)((wxDateTime const *)arg1)->IsValid();
21544
21545 wxPyEndAllowThreads(__tstate);
21546 if (PyErr_Occurred()) SWIG_fail;
21547 }
21548 {
21549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21550 }
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21558 PyObject *resultobj;
21559 wxDateTime *arg1 = (wxDateTime *) 0 ;
21560 time_t result;
21561 PyObject * obj0 = 0 ;
21562 char *kwnames[] = {
21563 (char *) "self", NULL
21564 };
21565
21566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21568 if (SWIG_arg_fail(1)) SWIG_fail;
21569 {
21570 PyThreadState* __tstate = wxPyBeginAllowThreads();
21571 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21572
21573 wxPyEndAllowThreads(__tstate);
21574 if (PyErr_Occurred()) SWIG_fail;
21575 }
21576 {
21577 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21578 }
21579 return resultobj;
21580 fail:
21581 return NULL;
21582 }
21583
21584
21585 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21586 PyObject *resultobj;
21587 wxDateTime *arg1 = (wxDateTime *) 0 ;
21588 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21589 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21590 int result;
21591 bool temp2 = false ;
21592 PyObject * obj0 = 0 ;
21593 PyObject * obj1 = 0 ;
21594 char *kwnames[] = {
21595 (char *) "self",(char *) "tz", NULL
21596 };
21597
21598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21600 if (SWIG_arg_fail(1)) SWIG_fail;
21601 if (obj1) {
21602 {
21603 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21604 temp2 = true;
21605 }
21606 }
21607 {
21608 PyThreadState* __tstate = wxPyBeginAllowThreads();
21609 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21610
21611 wxPyEndAllowThreads(__tstate);
21612 if (PyErr_Occurred()) SWIG_fail;
21613 }
21614 {
21615 resultobj = SWIG_From_int((int)(result));
21616 }
21617 {
21618 if (temp2) delete arg2;
21619 }
21620 return resultobj;
21621 fail:
21622 {
21623 if (temp2) delete arg2;
21624 }
21625 return NULL;
21626 }
21627
21628
21629 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21630 PyObject *resultobj;
21631 wxDateTime *arg1 = (wxDateTime *) 0 ;
21632 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21633 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21634 wxDateTime::Month result;
21635 bool temp2 = false ;
21636 PyObject * obj0 = 0 ;
21637 PyObject * obj1 = 0 ;
21638 char *kwnames[] = {
21639 (char *) "self",(char *) "tz", NULL
21640 };
21641
21642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21644 if (SWIG_arg_fail(1)) SWIG_fail;
21645 if (obj1) {
21646 {
21647 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21648 temp2 = true;
21649 }
21650 }
21651 {
21652 PyThreadState* __tstate = wxPyBeginAllowThreads();
21653 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21654
21655 wxPyEndAllowThreads(__tstate);
21656 if (PyErr_Occurred()) SWIG_fail;
21657 }
21658 resultobj = SWIG_From_int((result));
21659 {
21660 if (temp2) delete arg2;
21661 }
21662 return resultobj;
21663 fail:
21664 {
21665 if (temp2) delete arg2;
21666 }
21667 return NULL;
21668 }
21669
21670
21671 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21672 PyObject *resultobj;
21673 wxDateTime *arg1 = (wxDateTime *) 0 ;
21674 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21675 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21676 int result;
21677 bool temp2 = false ;
21678 PyObject * obj0 = 0 ;
21679 PyObject * obj1 = 0 ;
21680 char *kwnames[] = {
21681 (char *) "self",(char *) "tz", NULL
21682 };
21683
21684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21686 if (SWIG_arg_fail(1)) SWIG_fail;
21687 if (obj1) {
21688 {
21689 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21690 temp2 = true;
21691 }
21692 }
21693 {
21694 PyThreadState* __tstate = wxPyBeginAllowThreads();
21695 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21696
21697 wxPyEndAllowThreads(__tstate);
21698 if (PyErr_Occurred()) SWIG_fail;
21699 }
21700 {
21701 resultobj = SWIG_From_int((int)(result));
21702 }
21703 {
21704 if (temp2) delete arg2;
21705 }
21706 return resultobj;
21707 fail:
21708 {
21709 if (temp2) delete arg2;
21710 }
21711 return NULL;
21712 }
21713
21714
21715 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21716 PyObject *resultobj;
21717 wxDateTime *arg1 = (wxDateTime *) 0 ;
21718 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21719 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21720 wxDateTime::WeekDay result;
21721 bool temp2 = false ;
21722 PyObject * obj0 = 0 ;
21723 PyObject * obj1 = 0 ;
21724 char *kwnames[] = {
21725 (char *) "self",(char *) "tz", NULL
21726 };
21727
21728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21730 if (SWIG_arg_fail(1)) SWIG_fail;
21731 if (obj1) {
21732 {
21733 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21734 temp2 = true;
21735 }
21736 }
21737 {
21738 PyThreadState* __tstate = wxPyBeginAllowThreads();
21739 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21740
21741 wxPyEndAllowThreads(__tstate);
21742 if (PyErr_Occurred()) SWIG_fail;
21743 }
21744 resultobj = SWIG_From_int((result));
21745 {
21746 if (temp2) delete arg2;
21747 }
21748 return resultobj;
21749 fail:
21750 {
21751 if (temp2) delete arg2;
21752 }
21753 return NULL;
21754 }
21755
21756
21757 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21758 PyObject *resultobj;
21759 wxDateTime *arg1 = (wxDateTime *) 0 ;
21760 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21761 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21762 int result;
21763 bool temp2 = false ;
21764 PyObject * obj0 = 0 ;
21765 PyObject * obj1 = 0 ;
21766 char *kwnames[] = {
21767 (char *) "self",(char *) "tz", NULL
21768 };
21769
21770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21772 if (SWIG_arg_fail(1)) SWIG_fail;
21773 if (obj1) {
21774 {
21775 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21776 temp2 = true;
21777 }
21778 }
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21782
21783 wxPyEndAllowThreads(__tstate);
21784 if (PyErr_Occurred()) SWIG_fail;
21785 }
21786 {
21787 resultobj = SWIG_From_int((int)(result));
21788 }
21789 {
21790 if (temp2) delete arg2;
21791 }
21792 return resultobj;
21793 fail:
21794 {
21795 if (temp2) delete arg2;
21796 }
21797 return NULL;
21798 }
21799
21800
21801 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21802 PyObject *resultobj;
21803 wxDateTime *arg1 = (wxDateTime *) 0 ;
21804 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21805 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21806 int result;
21807 bool temp2 = false ;
21808 PyObject * obj0 = 0 ;
21809 PyObject * obj1 = 0 ;
21810 char *kwnames[] = {
21811 (char *) "self",(char *) "tz", NULL
21812 };
21813
21814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21816 if (SWIG_arg_fail(1)) SWIG_fail;
21817 if (obj1) {
21818 {
21819 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21820 temp2 = true;
21821 }
21822 }
21823 {
21824 PyThreadState* __tstate = wxPyBeginAllowThreads();
21825 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21826
21827 wxPyEndAllowThreads(__tstate);
21828 if (PyErr_Occurred()) SWIG_fail;
21829 }
21830 {
21831 resultobj = SWIG_From_int((int)(result));
21832 }
21833 {
21834 if (temp2) delete arg2;
21835 }
21836 return resultobj;
21837 fail:
21838 {
21839 if (temp2) delete arg2;
21840 }
21841 return NULL;
21842 }
21843
21844
21845 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21846 PyObject *resultobj;
21847 wxDateTime *arg1 = (wxDateTime *) 0 ;
21848 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21849 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21850 int result;
21851 bool temp2 = false ;
21852 PyObject * obj0 = 0 ;
21853 PyObject * obj1 = 0 ;
21854 char *kwnames[] = {
21855 (char *) "self",(char *) "tz", NULL
21856 };
21857
21858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21860 if (SWIG_arg_fail(1)) SWIG_fail;
21861 if (obj1) {
21862 {
21863 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21864 temp2 = true;
21865 }
21866 }
21867 {
21868 PyThreadState* __tstate = wxPyBeginAllowThreads();
21869 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21870
21871 wxPyEndAllowThreads(__tstate);
21872 if (PyErr_Occurred()) SWIG_fail;
21873 }
21874 {
21875 resultobj = SWIG_From_int((int)(result));
21876 }
21877 {
21878 if (temp2) delete arg2;
21879 }
21880 return resultobj;
21881 fail:
21882 {
21883 if (temp2) delete arg2;
21884 }
21885 return NULL;
21886 }
21887
21888
21889 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21890 PyObject *resultobj;
21891 wxDateTime *arg1 = (wxDateTime *) 0 ;
21892 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21893 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21894 int result;
21895 bool temp2 = false ;
21896 PyObject * obj0 = 0 ;
21897 PyObject * obj1 = 0 ;
21898 char *kwnames[] = {
21899 (char *) "self",(char *) "tz", NULL
21900 };
21901
21902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21904 if (SWIG_arg_fail(1)) SWIG_fail;
21905 if (obj1) {
21906 {
21907 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21908 temp2 = true;
21909 }
21910 }
21911 {
21912 PyThreadState* __tstate = wxPyBeginAllowThreads();
21913 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21914
21915 wxPyEndAllowThreads(__tstate);
21916 if (PyErr_Occurred()) SWIG_fail;
21917 }
21918 {
21919 resultobj = SWIG_From_int((int)(result));
21920 }
21921 {
21922 if (temp2) delete arg2;
21923 }
21924 return resultobj;
21925 fail:
21926 {
21927 if (temp2) delete arg2;
21928 }
21929 return NULL;
21930 }
21931
21932
21933 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21934 PyObject *resultobj;
21935 wxDateTime *arg1 = (wxDateTime *) 0 ;
21936 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21937 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21938 int result;
21939 bool temp2 = false ;
21940 PyObject * obj0 = 0 ;
21941 PyObject * obj1 = 0 ;
21942 char *kwnames[] = {
21943 (char *) "self",(char *) "tz", NULL
21944 };
21945
21946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21948 if (SWIG_arg_fail(1)) SWIG_fail;
21949 if (obj1) {
21950 {
21951 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21952 temp2 = true;
21953 }
21954 }
21955 {
21956 PyThreadState* __tstate = wxPyBeginAllowThreads();
21957 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21958
21959 wxPyEndAllowThreads(__tstate);
21960 if (PyErr_Occurred()) SWIG_fail;
21961 }
21962 {
21963 resultobj = SWIG_From_int((int)(result));
21964 }
21965 {
21966 if (temp2) delete arg2;
21967 }
21968 return resultobj;
21969 fail:
21970 {
21971 if (temp2) delete arg2;
21972 }
21973 return NULL;
21974 }
21975
21976
21977 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21978 PyObject *resultobj;
21979 wxDateTime *arg1 = (wxDateTime *) 0 ;
21980 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21981 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21982 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21983 int result;
21984 bool temp3 = false ;
21985 PyObject * obj0 = 0 ;
21986 PyObject * obj1 = 0 ;
21987 PyObject * obj2 = 0 ;
21988 char *kwnames[] = {
21989 (char *) "self",(char *) "flags",(char *) "tz", NULL
21990 };
21991
21992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21994 if (SWIG_arg_fail(1)) SWIG_fail;
21995 if (obj1) {
21996 {
21997 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21998 if (SWIG_arg_fail(2)) SWIG_fail;
21999 }
22000 }
22001 if (obj2) {
22002 {
22003 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22004 temp3 = true;
22005 }
22006 }
22007 {
22008 PyThreadState* __tstate = wxPyBeginAllowThreads();
22009 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22010
22011 wxPyEndAllowThreads(__tstate);
22012 if (PyErr_Occurred()) SWIG_fail;
22013 }
22014 {
22015 resultobj = SWIG_From_int((int)(result));
22016 }
22017 {
22018 if (temp3) delete arg3;
22019 }
22020 return resultobj;
22021 fail:
22022 {
22023 if (temp3) delete arg3;
22024 }
22025 return NULL;
22026 }
22027
22028
22029 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22030 PyObject *resultobj;
22031 wxDateTime *arg1 = (wxDateTime *) 0 ;
22032 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22033 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22034 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22035 int result;
22036 bool temp3 = false ;
22037 PyObject * obj0 = 0 ;
22038 PyObject * obj1 = 0 ;
22039 PyObject * obj2 = 0 ;
22040 char *kwnames[] = {
22041 (char *) "self",(char *) "flags",(char *) "tz", NULL
22042 };
22043
22044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
22045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22046 if (SWIG_arg_fail(1)) SWIG_fail;
22047 if (obj1) {
22048 {
22049 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22050 if (SWIG_arg_fail(2)) SWIG_fail;
22051 }
22052 }
22053 if (obj2) {
22054 {
22055 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22056 temp3 = true;
22057 }
22058 }
22059 {
22060 PyThreadState* __tstate = wxPyBeginAllowThreads();
22061 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22062
22063 wxPyEndAllowThreads(__tstate);
22064 if (PyErr_Occurred()) SWIG_fail;
22065 }
22066 {
22067 resultobj = SWIG_From_int((int)(result));
22068 }
22069 {
22070 if (temp3) delete arg3;
22071 }
22072 return resultobj;
22073 fail:
22074 {
22075 if (temp3) delete arg3;
22076 }
22077 return NULL;
22078 }
22079
22080
22081 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22082 PyObject *resultobj;
22083 wxDateTime *arg1 = (wxDateTime *) 0 ;
22084 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22085 bool result;
22086 PyObject * obj0 = 0 ;
22087 PyObject * obj1 = 0 ;
22088 char *kwnames[] = {
22089 (char *) "self",(char *) "country", NULL
22090 };
22091
22092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22094 if (SWIG_arg_fail(1)) SWIG_fail;
22095 if (obj1) {
22096 {
22097 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22098 if (SWIG_arg_fail(2)) SWIG_fail;
22099 }
22100 }
22101 {
22102 PyThreadState* __tstate = wxPyBeginAllowThreads();
22103 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22104
22105 wxPyEndAllowThreads(__tstate);
22106 if (PyErr_Occurred()) SWIG_fail;
22107 }
22108 {
22109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22110 }
22111 return resultobj;
22112 fail:
22113 return NULL;
22114 }
22115
22116
22117 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22118 PyObject *resultobj;
22119 wxDateTime *arg1 = (wxDateTime *) 0 ;
22120 wxDateTime *arg2 = 0 ;
22121 bool result;
22122 PyObject * obj0 = 0 ;
22123 PyObject * obj1 = 0 ;
22124 char *kwnames[] = {
22125 (char *) "self",(char *) "datetime", NULL
22126 };
22127
22128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22130 if (SWIG_arg_fail(1)) SWIG_fail;
22131 {
22132 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22133 if (SWIG_arg_fail(2)) SWIG_fail;
22134 if (arg2 == NULL) {
22135 SWIG_null_ref("wxDateTime");
22136 }
22137 if (SWIG_arg_fail(2)) SWIG_fail;
22138 }
22139 {
22140 PyThreadState* __tstate = wxPyBeginAllowThreads();
22141 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22142
22143 wxPyEndAllowThreads(__tstate);
22144 if (PyErr_Occurred()) SWIG_fail;
22145 }
22146 {
22147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22148 }
22149 return resultobj;
22150 fail:
22151 return NULL;
22152 }
22153
22154
22155 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22156 PyObject *resultobj;
22157 wxDateTime *arg1 = (wxDateTime *) 0 ;
22158 wxDateTime *arg2 = 0 ;
22159 bool result;
22160 PyObject * obj0 = 0 ;
22161 PyObject * obj1 = 0 ;
22162 char *kwnames[] = {
22163 (char *) "self",(char *) "datetime", NULL
22164 };
22165
22166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22168 if (SWIG_arg_fail(1)) SWIG_fail;
22169 {
22170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22171 if (SWIG_arg_fail(2)) SWIG_fail;
22172 if (arg2 == NULL) {
22173 SWIG_null_ref("wxDateTime");
22174 }
22175 if (SWIG_arg_fail(2)) SWIG_fail;
22176 }
22177 {
22178 PyThreadState* __tstate = wxPyBeginAllowThreads();
22179 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22180
22181 wxPyEndAllowThreads(__tstate);
22182 if (PyErr_Occurred()) SWIG_fail;
22183 }
22184 {
22185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22186 }
22187 return resultobj;
22188 fail:
22189 return NULL;
22190 }
22191
22192
22193 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22194 PyObject *resultobj;
22195 wxDateTime *arg1 = (wxDateTime *) 0 ;
22196 wxDateTime *arg2 = 0 ;
22197 bool result;
22198 PyObject * obj0 = 0 ;
22199 PyObject * obj1 = 0 ;
22200 char *kwnames[] = {
22201 (char *) "self",(char *) "datetime", NULL
22202 };
22203
22204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22206 if (SWIG_arg_fail(1)) SWIG_fail;
22207 {
22208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22209 if (SWIG_arg_fail(2)) SWIG_fail;
22210 if (arg2 == NULL) {
22211 SWIG_null_ref("wxDateTime");
22212 }
22213 if (SWIG_arg_fail(2)) SWIG_fail;
22214 }
22215 {
22216 PyThreadState* __tstate = wxPyBeginAllowThreads();
22217 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22218
22219 wxPyEndAllowThreads(__tstate);
22220 if (PyErr_Occurred()) SWIG_fail;
22221 }
22222 {
22223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22224 }
22225 return resultobj;
22226 fail:
22227 return NULL;
22228 }
22229
22230
22231 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22232 PyObject *resultobj;
22233 wxDateTime *arg1 = (wxDateTime *) 0 ;
22234 wxDateTime *arg2 = 0 ;
22235 wxDateTime *arg3 = 0 ;
22236 bool result;
22237 PyObject * obj0 = 0 ;
22238 PyObject * obj1 = 0 ;
22239 PyObject * obj2 = 0 ;
22240 char *kwnames[] = {
22241 (char *) "self",(char *) "t1",(char *) "t2", NULL
22242 };
22243
22244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22246 if (SWIG_arg_fail(1)) SWIG_fail;
22247 {
22248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22249 if (SWIG_arg_fail(2)) SWIG_fail;
22250 if (arg2 == NULL) {
22251 SWIG_null_ref("wxDateTime");
22252 }
22253 if (SWIG_arg_fail(2)) SWIG_fail;
22254 }
22255 {
22256 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22257 if (SWIG_arg_fail(3)) SWIG_fail;
22258 if (arg3 == NULL) {
22259 SWIG_null_ref("wxDateTime");
22260 }
22261 if (SWIG_arg_fail(3)) SWIG_fail;
22262 }
22263 {
22264 PyThreadState* __tstate = wxPyBeginAllowThreads();
22265 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22266
22267 wxPyEndAllowThreads(__tstate);
22268 if (PyErr_Occurred()) SWIG_fail;
22269 }
22270 {
22271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22272 }
22273 return resultobj;
22274 fail:
22275 return NULL;
22276 }
22277
22278
22279 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22280 PyObject *resultobj;
22281 wxDateTime *arg1 = (wxDateTime *) 0 ;
22282 wxDateTime *arg2 = 0 ;
22283 wxDateTime *arg3 = 0 ;
22284 bool result;
22285 PyObject * obj0 = 0 ;
22286 PyObject * obj1 = 0 ;
22287 PyObject * obj2 = 0 ;
22288 char *kwnames[] = {
22289 (char *) "self",(char *) "t1",(char *) "t2", NULL
22290 };
22291
22292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22294 if (SWIG_arg_fail(1)) SWIG_fail;
22295 {
22296 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22297 if (SWIG_arg_fail(2)) SWIG_fail;
22298 if (arg2 == NULL) {
22299 SWIG_null_ref("wxDateTime");
22300 }
22301 if (SWIG_arg_fail(2)) SWIG_fail;
22302 }
22303 {
22304 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22305 if (SWIG_arg_fail(3)) SWIG_fail;
22306 if (arg3 == NULL) {
22307 SWIG_null_ref("wxDateTime");
22308 }
22309 if (SWIG_arg_fail(3)) SWIG_fail;
22310 }
22311 {
22312 PyThreadState* __tstate = wxPyBeginAllowThreads();
22313 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22314
22315 wxPyEndAllowThreads(__tstate);
22316 if (PyErr_Occurred()) SWIG_fail;
22317 }
22318 {
22319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22320 }
22321 return resultobj;
22322 fail:
22323 return NULL;
22324 }
22325
22326
22327 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22328 PyObject *resultobj;
22329 wxDateTime *arg1 = (wxDateTime *) 0 ;
22330 wxDateTime *arg2 = 0 ;
22331 bool result;
22332 PyObject * obj0 = 0 ;
22333 PyObject * obj1 = 0 ;
22334 char *kwnames[] = {
22335 (char *) "self",(char *) "dt", NULL
22336 };
22337
22338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22340 if (SWIG_arg_fail(1)) SWIG_fail;
22341 {
22342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22343 if (SWIG_arg_fail(2)) SWIG_fail;
22344 if (arg2 == NULL) {
22345 SWIG_null_ref("wxDateTime");
22346 }
22347 if (SWIG_arg_fail(2)) SWIG_fail;
22348 }
22349 {
22350 PyThreadState* __tstate = wxPyBeginAllowThreads();
22351 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22352
22353 wxPyEndAllowThreads(__tstate);
22354 if (PyErr_Occurred()) SWIG_fail;
22355 }
22356 {
22357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22358 }
22359 return resultobj;
22360 fail:
22361 return NULL;
22362 }
22363
22364
22365 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22366 PyObject *resultobj;
22367 wxDateTime *arg1 = (wxDateTime *) 0 ;
22368 wxDateTime *arg2 = 0 ;
22369 bool result;
22370 PyObject * obj0 = 0 ;
22371 PyObject * obj1 = 0 ;
22372 char *kwnames[] = {
22373 (char *) "self",(char *) "dt", NULL
22374 };
22375
22376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22378 if (SWIG_arg_fail(1)) SWIG_fail;
22379 {
22380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22381 if (SWIG_arg_fail(2)) SWIG_fail;
22382 if (arg2 == NULL) {
22383 SWIG_null_ref("wxDateTime");
22384 }
22385 if (SWIG_arg_fail(2)) SWIG_fail;
22386 }
22387 {
22388 PyThreadState* __tstate = wxPyBeginAllowThreads();
22389 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22390
22391 wxPyEndAllowThreads(__tstate);
22392 if (PyErr_Occurred()) SWIG_fail;
22393 }
22394 {
22395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22396 }
22397 return resultobj;
22398 fail:
22399 return NULL;
22400 }
22401
22402
22403 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22404 PyObject *resultobj;
22405 wxDateTime *arg1 = (wxDateTime *) 0 ;
22406 wxDateTime *arg2 = 0 ;
22407 wxTimeSpan *arg3 = 0 ;
22408 bool result;
22409 PyObject * obj0 = 0 ;
22410 PyObject * obj1 = 0 ;
22411 PyObject * obj2 = 0 ;
22412 char *kwnames[] = {
22413 (char *) "self",(char *) "dt",(char *) "ts", NULL
22414 };
22415
22416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22418 if (SWIG_arg_fail(1)) SWIG_fail;
22419 {
22420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22421 if (SWIG_arg_fail(2)) SWIG_fail;
22422 if (arg2 == NULL) {
22423 SWIG_null_ref("wxDateTime");
22424 }
22425 if (SWIG_arg_fail(2)) SWIG_fail;
22426 }
22427 {
22428 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22429 if (SWIG_arg_fail(3)) SWIG_fail;
22430 if (arg3 == NULL) {
22431 SWIG_null_ref("wxTimeSpan");
22432 }
22433 if (SWIG_arg_fail(3)) SWIG_fail;
22434 }
22435 {
22436 PyThreadState* __tstate = wxPyBeginAllowThreads();
22437 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22438
22439 wxPyEndAllowThreads(__tstate);
22440 if (PyErr_Occurred()) SWIG_fail;
22441 }
22442 {
22443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22444 }
22445 return resultobj;
22446 fail:
22447 return NULL;
22448 }
22449
22450
22451 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22452 PyObject *resultobj;
22453 wxDateTime *arg1 = (wxDateTime *) 0 ;
22454 wxTimeSpan *arg2 = 0 ;
22455 wxDateTime *result;
22456 PyObject * obj0 = 0 ;
22457 PyObject * obj1 = 0 ;
22458 char *kwnames[] = {
22459 (char *) "self",(char *) "diff", NULL
22460 };
22461
22462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22464 if (SWIG_arg_fail(1)) SWIG_fail;
22465 {
22466 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22467 if (SWIG_arg_fail(2)) SWIG_fail;
22468 if (arg2 == NULL) {
22469 SWIG_null_ref("wxTimeSpan");
22470 }
22471 if (SWIG_arg_fail(2)) SWIG_fail;
22472 }
22473 {
22474 PyThreadState* __tstate = wxPyBeginAllowThreads();
22475 {
22476 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22477 result = (wxDateTime *) &_result_ref;
22478 }
22479
22480 wxPyEndAllowThreads(__tstate);
22481 if (PyErr_Occurred()) SWIG_fail;
22482 }
22483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22484 return resultobj;
22485 fail:
22486 return NULL;
22487 }
22488
22489
22490 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22491 PyObject *resultobj;
22492 wxDateTime *arg1 = (wxDateTime *) 0 ;
22493 wxDateSpan *arg2 = 0 ;
22494 wxDateTime *result;
22495 PyObject * obj0 = 0 ;
22496 PyObject * obj1 = 0 ;
22497 char *kwnames[] = {
22498 (char *) "self",(char *) "diff", NULL
22499 };
22500
22501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22503 if (SWIG_arg_fail(1)) SWIG_fail;
22504 {
22505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22506 if (SWIG_arg_fail(2)) SWIG_fail;
22507 if (arg2 == NULL) {
22508 SWIG_null_ref("wxDateSpan");
22509 }
22510 if (SWIG_arg_fail(2)) SWIG_fail;
22511 }
22512 {
22513 PyThreadState* __tstate = wxPyBeginAllowThreads();
22514 {
22515 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22516 result = (wxDateTime *) &_result_ref;
22517 }
22518
22519 wxPyEndAllowThreads(__tstate);
22520 if (PyErr_Occurred()) SWIG_fail;
22521 }
22522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22523 return resultobj;
22524 fail:
22525 return NULL;
22526 }
22527
22528
22529 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22530 PyObject *resultobj;
22531 wxDateTime *arg1 = (wxDateTime *) 0 ;
22532 wxTimeSpan *arg2 = 0 ;
22533 wxDateTime *result;
22534 PyObject * obj0 = 0 ;
22535 PyObject * obj1 = 0 ;
22536 char *kwnames[] = {
22537 (char *) "self",(char *) "diff", NULL
22538 };
22539
22540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22542 if (SWIG_arg_fail(1)) SWIG_fail;
22543 {
22544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22545 if (SWIG_arg_fail(2)) SWIG_fail;
22546 if (arg2 == NULL) {
22547 SWIG_null_ref("wxTimeSpan");
22548 }
22549 if (SWIG_arg_fail(2)) SWIG_fail;
22550 }
22551 {
22552 PyThreadState* __tstate = wxPyBeginAllowThreads();
22553 {
22554 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22555 result = (wxDateTime *) &_result_ref;
22556 }
22557
22558 wxPyEndAllowThreads(__tstate);
22559 if (PyErr_Occurred()) SWIG_fail;
22560 }
22561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22562 return resultobj;
22563 fail:
22564 return NULL;
22565 }
22566
22567
22568 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22569 PyObject *resultobj;
22570 wxDateTime *arg1 = (wxDateTime *) 0 ;
22571 wxDateSpan *arg2 = 0 ;
22572 wxDateTime *result;
22573 PyObject * obj0 = 0 ;
22574 PyObject * obj1 = 0 ;
22575 char *kwnames[] = {
22576 (char *) "self",(char *) "diff", NULL
22577 };
22578
22579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22581 if (SWIG_arg_fail(1)) SWIG_fail;
22582 {
22583 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22584 if (SWIG_arg_fail(2)) SWIG_fail;
22585 if (arg2 == NULL) {
22586 SWIG_null_ref("wxDateSpan");
22587 }
22588 if (SWIG_arg_fail(2)) SWIG_fail;
22589 }
22590 {
22591 PyThreadState* __tstate = wxPyBeginAllowThreads();
22592 {
22593 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22594 result = (wxDateTime *) &_result_ref;
22595 }
22596
22597 wxPyEndAllowThreads(__tstate);
22598 if (PyErr_Occurred()) SWIG_fail;
22599 }
22600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22601 return resultobj;
22602 fail:
22603 return NULL;
22604 }
22605
22606
22607 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22608 PyObject *resultobj;
22609 wxDateTime *arg1 = (wxDateTime *) 0 ;
22610 wxDateTime *arg2 = 0 ;
22611 wxTimeSpan result;
22612 PyObject * obj0 = 0 ;
22613 PyObject * obj1 = 0 ;
22614 char *kwnames[] = {
22615 (char *) "self",(char *) "dt", NULL
22616 };
22617
22618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22620 if (SWIG_arg_fail(1)) SWIG_fail;
22621 {
22622 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22623 if (SWIG_arg_fail(2)) SWIG_fail;
22624 if (arg2 == NULL) {
22625 SWIG_null_ref("wxDateTime");
22626 }
22627 if (SWIG_arg_fail(2)) SWIG_fail;
22628 }
22629 {
22630 PyThreadState* __tstate = wxPyBeginAllowThreads();
22631 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22632
22633 wxPyEndAllowThreads(__tstate);
22634 if (PyErr_Occurred()) SWIG_fail;
22635 }
22636 {
22637 wxTimeSpan * resultptr;
22638 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22639 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22640 }
22641 return resultobj;
22642 fail:
22643 return NULL;
22644 }
22645
22646
22647 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22648 PyObject *resultobj;
22649 wxDateTime *arg1 = (wxDateTime *) 0 ;
22650 wxTimeSpan *arg2 = 0 ;
22651 wxDateTime *result;
22652 PyObject * obj0 = 0 ;
22653 PyObject * obj1 = 0 ;
22654
22655 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22657 if (SWIG_arg_fail(1)) SWIG_fail;
22658 {
22659 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22660 if (SWIG_arg_fail(2)) SWIG_fail;
22661 if (arg2 == NULL) {
22662 SWIG_null_ref("wxTimeSpan");
22663 }
22664 if (SWIG_arg_fail(2)) SWIG_fail;
22665 }
22666 {
22667 PyThreadState* __tstate = wxPyBeginAllowThreads();
22668 {
22669 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22670 result = (wxDateTime *) &_result_ref;
22671 }
22672
22673 wxPyEndAllowThreads(__tstate);
22674 if (PyErr_Occurred()) SWIG_fail;
22675 }
22676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22677 return resultobj;
22678 fail:
22679 return NULL;
22680 }
22681
22682
22683 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22684 PyObject *resultobj;
22685 wxDateTime *arg1 = (wxDateTime *) 0 ;
22686 wxDateSpan *arg2 = 0 ;
22687 wxDateTime *result;
22688 PyObject * obj0 = 0 ;
22689 PyObject * obj1 = 0 ;
22690
22691 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22693 if (SWIG_arg_fail(1)) SWIG_fail;
22694 {
22695 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22696 if (SWIG_arg_fail(2)) SWIG_fail;
22697 if (arg2 == NULL) {
22698 SWIG_null_ref("wxDateSpan");
22699 }
22700 if (SWIG_arg_fail(2)) SWIG_fail;
22701 }
22702 {
22703 PyThreadState* __tstate = wxPyBeginAllowThreads();
22704 {
22705 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22706 result = (wxDateTime *) &_result_ref;
22707 }
22708
22709 wxPyEndAllowThreads(__tstate);
22710 if (PyErr_Occurred()) SWIG_fail;
22711 }
22712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22713 return resultobj;
22714 fail:
22715 return NULL;
22716 }
22717
22718
22719 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22720 int argc;
22721 PyObject *argv[3];
22722 int ii;
22723
22724 argc = PyObject_Length(args);
22725 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22726 argv[ii] = PyTuple_GetItem(args,ii);
22727 }
22728 if (argc == 2) {
22729 int _v;
22730 {
22731 void *ptr;
22732 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22733 _v = 0;
22734 PyErr_Clear();
22735 } else {
22736 _v = 1;
22737 }
22738 }
22739 if (_v) {
22740 {
22741 void *ptr = 0;
22742 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22743 _v = 0;
22744 PyErr_Clear();
22745 } else {
22746 _v = (ptr != 0);
22747 }
22748 }
22749 if (_v) {
22750 return _wrap_DateTime___iadd____SWIG_0(self,args);
22751 }
22752 }
22753 }
22754 if (argc == 2) {
22755 int _v;
22756 {
22757 void *ptr;
22758 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22759 _v = 0;
22760 PyErr_Clear();
22761 } else {
22762 _v = 1;
22763 }
22764 }
22765 if (_v) {
22766 {
22767 void *ptr = 0;
22768 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22769 _v = 0;
22770 PyErr_Clear();
22771 } else {
22772 _v = (ptr != 0);
22773 }
22774 }
22775 if (_v) {
22776 return _wrap_DateTime___iadd____SWIG_1(self,args);
22777 }
22778 }
22779 }
22780
22781 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22782 return NULL;
22783 }
22784
22785
22786 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22787 PyObject *resultobj;
22788 wxDateTime *arg1 = (wxDateTime *) 0 ;
22789 wxTimeSpan *arg2 = 0 ;
22790 wxDateTime *result;
22791 PyObject * obj0 = 0 ;
22792 PyObject * obj1 = 0 ;
22793
22794 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22796 if (SWIG_arg_fail(1)) SWIG_fail;
22797 {
22798 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22799 if (SWIG_arg_fail(2)) SWIG_fail;
22800 if (arg2 == NULL) {
22801 SWIG_null_ref("wxTimeSpan");
22802 }
22803 if (SWIG_arg_fail(2)) SWIG_fail;
22804 }
22805 {
22806 PyThreadState* __tstate = wxPyBeginAllowThreads();
22807 {
22808 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22809 result = (wxDateTime *) &_result_ref;
22810 }
22811
22812 wxPyEndAllowThreads(__tstate);
22813 if (PyErr_Occurred()) SWIG_fail;
22814 }
22815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22816 return resultobj;
22817 fail:
22818 return NULL;
22819 }
22820
22821
22822 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22823 PyObject *resultobj;
22824 wxDateTime *arg1 = (wxDateTime *) 0 ;
22825 wxDateSpan *arg2 = 0 ;
22826 wxDateTime *result;
22827 PyObject * obj0 = 0 ;
22828 PyObject * obj1 = 0 ;
22829
22830 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22832 if (SWIG_arg_fail(1)) SWIG_fail;
22833 {
22834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22835 if (SWIG_arg_fail(2)) SWIG_fail;
22836 if (arg2 == NULL) {
22837 SWIG_null_ref("wxDateSpan");
22838 }
22839 if (SWIG_arg_fail(2)) SWIG_fail;
22840 }
22841 {
22842 PyThreadState* __tstate = wxPyBeginAllowThreads();
22843 {
22844 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22845 result = (wxDateTime *) &_result_ref;
22846 }
22847
22848 wxPyEndAllowThreads(__tstate);
22849 if (PyErr_Occurred()) SWIG_fail;
22850 }
22851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22852 return resultobj;
22853 fail:
22854 return NULL;
22855 }
22856
22857
22858 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22859 int argc;
22860 PyObject *argv[3];
22861 int ii;
22862
22863 argc = PyObject_Length(args);
22864 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22865 argv[ii] = PyTuple_GetItem(args,ii);
22866 }
22867 if (argc == 2) {
22868 int _v;
22869 {
22870 void *ptr;
22871 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22872 _v = 0;
22873 PyErr_Clear();
22874 } else {
22875 _v = 1;
22876 }
22877 }
22878 if (_v) {
22879 {
22880 void *ptr = 0;
22881 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22882 _v = 0;
22883 PyErr_Clear();
22884 } else {
22885 _v = (ptr != 0);
22886 }
22887 }
22888 if (_v) {
22889 return _wrap_DateTime___isub____SWIG_0(self,args);
22890 }
22891 }
22892 }
22893 if (argc == 2) {
22894 int _v;
22895 {
22896 void *ptr;
22897 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22898 _v = 0;
22899 PyErr_Clear();
22900 } else {
22901 _v = 1;
22902 }
22903 }
22904 if (_v) {
22905 {
22906 void *ptr = 0;
22907 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22908 _v = 0;
22909 PyErr_Clear();
22910 } else {
22911 _v = (ptr != 0);
22912 }
22913 }
22914 if (_v) {
22915 return _wrap_DateTime___isub____SWIG_1(self,args);
22916 }
22917 }
22918 }
22919
22920 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22921 return NULL;
22922 }
22923
22924
22925 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22926 PyObject *resultobj;
22927 wxDateTime *arg1 = (wxDateTime *) 0 ;
22928 wxTimeSpan *arg2 = 0 ;
22929 wxDateTime result;
22930 PyObject * obj0 = 0 ;
22931 PyObject * obj1 = 0 ;
22932
22933 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22935 if (SWIG_arg_fail(1)) SWIG_fail;
22936 {
22937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22938 if (SWIG_arg_fail(2)) SWIG_fail;
22939 if (arg2 == NULL) {
22940 SWIG_null_ref("wxTimeSpan");
22941 }
22942 if (SWIG_arg_fail(2)) SWIG_fail;
22943 }
22944 {
22945 PyThreadState* __tstate = wxPyBeginAllowThreads();
22946 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22947
22948 wxPyEndAllowThreads(__tstate);
22949 if (PyErr_Occurred()) SWIG_fail;
22950 }
22951 {
22952 wxDateTime * resultptr;
22953 resultptr = new wxDateTime((wxDateTime &)(result));
22954 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22955 }
22956 return resultobj;
22957 fail:
22958 return NULL;
22959 }
22960
22961
22962 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22963 PyObject *resultobj;
22964 wxDateTime *arg1 = (wxDateTime *) 0 ;
22965 wxDateSpan *arg2 = 0 ;
22966 wxDateTime result;
22967 PyObject * obj0 = 0 ;
22968 PyObject * obj1 = 0 ;
22969
22970 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22972 if (SWIG_arg_fail(1)) SWIG_fail;
22973 {
22974 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22975 if (SWIG_arg_fail(2)) SWIG_fail;
22976 if (arg2 == NULL) {
22977 SWIG_null_ref("wxDateSpan");
22978 }
22979 if (SWIG_arg_fail(2)) SWIG_fail;
22980 }
22981 {
22982 PyThreadState* __tstate = wxPyBeginAllowThreads();
22983 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22984
22985 wxPyEndAllowThreads(__tstate);
22986 if (PyErr_Occurred()) SWIG_fail;
22987 }
22988 {
22989 wxDateTime * resultptr;
22990 resultptr = new wxDateTime((wxDateTime &)(result));
22991 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22992 }
22993 return resultobj;
22994 fail:
22995 return NULL;
22996 }
22997
22998
22999 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
23000 int argc;
23001 PyObject *argv[3];
23002 int ii;
23003
23004 argc = PyObject_Length(args);
23005 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23006 argv[ii] = PyTuple_GetItem(args,ii);
23007 }
23008 if (argc == 2) {
23009 int _v;
23010 {
23011 void *ptr;
23012 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23013 _v = 0;
23014 PyErr_Clear();
23015 } else {
23016 _v = 1;
23017 }
23018 }
23019 if (_v) {
23020 {
23021 void *ptr = 0;
23022 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23023 _v = 0;
23024 PyErr_Clear();
23025 } else {
23026 _v = (ptr != 0);
23027 }
23028 }
23029 if (_v) {
23030 return _wrap_DateTime___add____SWIG_0(self,args);
23031 }
23032 }
23033 }
23034 if (argc == 2) {
23035 int _v;
23036 {
23037 void *ptr;
23038 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23039 _v = 0;
23040 PyErr_Clear();
23041 } else {
23042 _v = 1;
23043 }
23044 }
23045 if (_v) {
23046 {
23047 void *ptr = 0;
23048 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23049 _v = 0;
23050 PyErr_Clear();
23051 } else {
23052 _v = (ptr != 0);
23053 }
23054 }
23055 if (_v) {
23056 return _wrap_DateTime___add____SWIG_1(self,args);
23057 }
23058 }
23059 }
23060
23061 Py_INCREF(Py_NotImplemented);
23062 return Py_NotImplemented;
23063 }
23064
23065
23066 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23067 PyObject *resultobj;
23068 wxDateTime *arg1 = (wxDateTime *) 0 ;
23069 wxDateTime *arg2 = 0 ;
23070 wxTimeSpan result;
23071 PyObject * obj0 = 0 ;
23072 PyObject * obj1 = 0 ;
23073
23074 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23076 if (SWIG_arg_fail(1)) SWIG_fail;
23077 {
23078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23079 if (SWIG_arg_fail(2)) SWIG_fail;
23080 if (arg2 == NULL) {
23081 SWIG_null_ref("wxDateTime");
23082 }
23083 if (SWIG_arg_fail(2)) SWIG_fail;
23084 }
23085 {
23086 PyThreadState* __tstate = wxPyBeginAllowThreads();
23087 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23088
23089 wxPyEndAllowThreads(__tstate);
23090 if (PyErr_Occurred()) SWIG_fail;
23091 }
23092 {
23093 wxTimeSpan * resultptr;
23094 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23095 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23096 }
23097 return resultobj;
23098 fail:
23099 return NULL;
23100 }
23101
23102
23103 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23104 PyObject *resultobj;
23105 wxDateTime *arg1 = (wxDateTime *) 0 ;
23106 wxTimeSpan *arg2 = 0 ;
23107 wxDateTime result;
23108 PyObject * obj0 = 0 ;
23109 PyObject * obj1 = 0 ;
23110
23111 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23116 if (SWIG_arg_fail(2)) SWIG_fail;
23117 if (arg2 == NULL) {
23118 SWIG_null_ref("wxTimeSpan");
23119 }
23120 if (SWIG_arg_fail(2)) SWIG_fail;
23121 }
23122 {
23123 PyThreadState* __tstate = wxPyBeginAllowThreads();
23124 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23125
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 {
23130 wxDateTime * resultptr;
23131 resultptr = new wxDateTime((wxDateTime &)(result));
23132 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23133 }
23134 return resultobj;
23135 fail:
23136 return NULL;
23137 }
23138
23139
23140 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23141 PyObject *resultobj;
23142 wxDateTime *arg1 = (wxDateTime *) 0 ;
23143 wxDateSpan *arg2 = 0 ;
23144 wxDateTime result;
23145 PyObject * obj0 = 0 ;
23146 PyObject * obj1 = 0 ;
23147
23148 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23150 if (SWIG_arg_fail(1)) SWIG_fail;
23151 {
23152 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23153 if (SWIG_arg_fail(2)) SWIG_fail;
23154 if (arg2 == NULL) {
23155 SWIG_null_ref("wxDateSpan");
23156 }
23157 if (SWIG_arg_fail(2)) SWIG_fail;
23158 }
23159 {
23160 PyThreadState* __tstate = wxPyBeginAllowThreads();
23161 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23162
23163 wxPyEndAllowThreads(__tstate);
23164 if (PyErr_Occurred()) SWIG_fail;
23165 }
23166 {
23167 wxDateTime * resultptr;
23168 resultptr = new wxDateTime((wxDateTime &)(result));
23169 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23170 }
23171 return resultobj;
23172 fail:
23173 return NULL;
23174 }
23175
23176
23177 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23178 int argc;
23179 PyObject *argv[3];
23180 int ii;
23181
23182 argc = PyObject_Length(args);
23183 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23184 argv[ii] = PyTuple_GetItem(args,ii);
23185 }
23186 if (argc == 2) {
23187 int _v;
23188 {
23189 void *ptr;
23190 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23191 _v = 0;
23192 PyErr_Clear();
23193 } else {
23194 _v = 1;
23195 }
23196 }
23197 if (_v) {
23198 {
23199 void *ptr = 0;
23200 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23201 _v = 0;
23202 PyErr_Clear();
23203 } else {
23204 _v = (ptr != 0);
23205 }
23206 }
23207 if (_v) {
23208 return _wrap_DateTime___sub____SWIG_0(self,args);
23209 }
23210 }
23211 }
23212 if (argc == 2) {
23213 int _v;
23214 {
23215 void *ptr;
23216 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23217 _v = 0;
23218 PyErr_Clear();
23219 } else {
23220 _v = 1;
23221 }
23222 }
23223 if (_v) {
23224 {
23225 void *ptr = 0;
23226 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23227 _v = 0;
23228 PyErr_Clear();
23229 } else {
23230 _v = (ptr != 0);
23231 }
23232 }
23233 if (_v) {
23234 return _wrap_DateTime___sub____SWIG_1(self,args);
23235 }
23236 }
23237 }
23238 if (argc == 2) {
23239 int _v;
23240 {
23241 void *ptr;
23242 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23243 _v = 0;
23244 PyErr_Clear();
23245 } else {
23246 _v = 1;
23247 }
23248 }
23249 if (_v) {
23250 {
23251 void *ptr = 0;
23252 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23253 _v = 0;
23254 PyErr_Clear();
23255 } else {
23256 _v = (ptr != 0);
23257 }
23258 }
23259 if (_v) {
23260 return _wrap_DateTime___sub____SWIG_2(self,args);
23261 }
23262 }
23263 }
23264
23265 Py_INCREF(Py_NotImplemented);
23266 return Py_NotImplemented;
23267 }
23268
23269
23270 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23271 PyObject *resultobj;
23272 wxDateTime *arg1 = (wxDateTime *) 0 ;
23273 wxDateTime *arg2 = (wxDateTime *) 0 ;
23274 bool result;
23275 PyObject * obj0 = 0 ;
23276 PyObject * obj1 = 0 ;
23277 char *kwnames[] = {
23278 (char *) "self",(char *) "other", NULL
23279 };
23280
23281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23283 if (SWIG_arg_fail(1)) SWIG_fail;
23284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23285 if (SWIG_arg_fail(2)) SWIG_fail;
23286 {
23287 PyThreadState* __tstate = wxPyBeginAllowThreads();
23288 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23289
23290 wxPyEndAllowThreads(__tstate);
23291 if (PyErr_Occurred()) SWIG_fail;
23292 }
23293 {
23294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23295 }
23296 return resultobj;
23297 fail:
23298 return NULL;
23299 }
23300
23301
23302 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23303 PyObject *resultobj;
23304 wxDateTime *arg1 = (wxDateTime *) 0 ;
23305 wxDateTime *arg2 = (wxDateTime *) 0 ;
23306 bool result;
23307 PyObject * obj0 = 0 ;
23308 PyObject * obj1 = 0 ;
23309 char *kwnames[] = {
23310 (char *) "self",(char *) "other", NULL
23311 };
23312
23313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23315 if (SWIG_arg_fail(1)) SWIG_fail;
23316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23317 if (SWIG_arg_fail(2)) SWIG_fail;
23318 {
23319 PyThreadState* __tstate = wxPyBeginAllowThreads();
23320 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23321
23322 wxPyEndAllowThreads(__tstate);
23323 if (PyErr_Occurred()) SWIG_fail;
23324 }
23325 {
23326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23327 }
23328 return resultobj;
23329 fail:
23330 return NULL;
23331 }
23332
23333
23334 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23335 PyObject *resultobj;
23336 wxDateTime *arg1 = (wxDateTime *) 0 ;
23337 wxDateTime *arg2 = (wxDateTime *) 0 ;
23338 bool result;
23339 PyObject * obj0 = 0 ;
23340 PyObject * obj1 = 0 ;
23341 char *kwnames[] = {
23342 (char *) "self",(char *) "other", NULL
23343 };
23344
23345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23347 if (SWIG_arg_fail(1)) SWIG_fail;
23348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23349 if (SWIG_arg_fail(2)) SWIG_fail;
23350 {
23351 PyThreadState* __tstate = wxPyBeginAllowThreads();
23352 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23353
23354 wxPyEndAllowThreads(__tstate);
23355 if (PyErr_Occurred()) SWIG_fail;
23356 }
23357 {
23358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23359 }
23360 return resultobj;
23361 fail:
23362 return NULL;
23363 }
23364
23365
23366 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23367 PyObject *resultobj;
23368 wxDateTime *arg1 = (wxDateTime *) 0 ;
23369 wxDateTime *arg2 = (wxDateTime *) 0 ;
23370 bool result;
23371 PyObject * obj0 = 0 ;
23372 PyObject * obj1 = 0 ;
23373 char *kwnames[] = {
23374 (char *) "self",(char *) "other", NULL
23375 };
23376
23377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23379 if (SWIG_arg_fail(1)) SWIG_fail;
23380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23381 if (SWIG_arg_fail(2)) SWIG_fail;
23382 {
23383 PyThreadState* __tstate = wxPyBeginAllowThreads();
23384 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23385
23386 wxPyEndAllowThreads(__tstate);
23387 if (PyErr_Occurred()) SWIG_fail;
23388 }
23389 {
23390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23391 }
23392 return resultobj;
23393 fail:
23394 return NULL;
23395 }
23396
23397
23398 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23399 PyObject *resultobj;
23400 wxDateTime *arg1 = (wxDateTime *) 0 ;
23401 wxDateTime *arg2 = (wxDateTime *) 0 ;
23402 bool result;
23403 PyObject * obj0 = 0 ;
23404 PyObject * obj1 = 0 ;
23405 char *kwnames[] = {
23406 (char *) "self",(char *) "other", NULL
23407 };
23408
23409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23411 if (SWIG_arg_fail(1)) SWIG_fail;
23412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23413 if (SWIG_arg_fail(2)) SWIG_fail;
23414 {
23415 PyThreadState* __tstate = wxPyBeginAllowThreads();
23416 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23417
23418 wxPyEndAllowThreads(__tstate);
23419 if (PyErr_Occurred()) SWIG_fail;
23420 }
23421 {
23422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23423 }
23424 return resultobj;
23425 fail:
23426 return NULL;
23427 }
23428
23429
23430 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23431 PyObject *resultobj;
23432 wxDateTime *arg1 = (wxDateTime *) 0 ;
23433 wxDateTime *arg2 = (wxDateTime *) 0 ;
23434 bool result;
23435 PyObject * obj0 = 0 ;
23436 PyObject * obj1 = 0 ;
23437 char *kwnames[] = {
23438 (char *) "self",(char *) "other", NULL
23439 };
23440
23441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23443 if (SWIG_arg_fail(1)) SWIG_fail;
23444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23445 if (SWIG_arg_fail(2)) SWIG_fail;
23446 {
23447 PyThreadState* __tstate = wxPyBeginAllowThreads();
23448 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23449
23450 wxPyEndAllowThreads(__tstate);
23451 if (PyErr_Occurred()) SWIG_fail;
23452 }
23453 {
23454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23455 }
23456 return resultobj;
23457 fail:
23458 return NULL;
23459 }
23460
23461
23462 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23463 PyObject *resultobj;
23464 wxDateTime *arg1 = (wxDateTime *) 0 ;
23465 wxString *arg2 = 0 ;
23466 int result;
23467 bool temp2 = false ;
23468 PyObject * obj0 = 0 ;
23469 PyObject * obj1 = 0 ;
23470 char *kwnames[] = {
23471 (char *) "self",(char *) "date", NULL
23472 };
23473
23474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23476 if (SWIG_arg_fail(1)) SWIG_fail;
23477 {
23478 arg2 = wxString_in_helper(obj1);
23479 if (arg2 == NULL) SWIG_fail;
23480 temp2 = true;
23481 }
23482 {
23483 PyThreadState* __tstate = wxPyBeginAllowThreads();
23484 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23485
23486 wxPyEndAllowThreads(__tstate);
23487 if (PyErr_Occurred()) SWIG_fail;
23488 }
23489 {
23490 resultobj = SWIG_From_int((int)(result));
23491 }
23492 {
23493 if (temp2)
23494 delete arg2;
23495 }
23496 return resultobj;
23497 fail:
23498 {
23499 if (temp2)
23500 delete arg2;
23501 }
23502 return NULL;
23503 }
23504
23505
23506 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23507 PyObject *resultobj;
23508 wxDateTime *arg1 = (wxDateTime *) 0 ;
23509 wxString *arg2 = 0 ;
23510 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23511 wxString *arg3 = (wxString *) &arg3_defvalue ;
23512 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23513 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23514 int result;
23515 bool temp2 = false ;
23516 bool temp3 = false ;
23517 PyObject * obj0 = 0 ;
23518 PyObject * obj1 = 0 ;
23519 PyObject * obj2 = 0 ;
23520 PyObject * obj3 = 0 ;
23521 char *kwnames[] = {
23522 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23523 };
23524
23525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23527 if (SWIG_arg_fail(1)) SWIG_fail;
23528 {
23529 arg2 = wxString_in_helper(obj1);
23530 if (arg2 == NULL) SWIG_fail;
23531 temp2 = true;
23532 }
23533 if (obj2) {
23534 {
23535 arg3 = wxString_in_helper(obj2);
23536 if (arg3 == NULL) SWIG_fail;
23537 temp3 = true;
23538 }
23539 }
23540 if (obj3) {
23541 {
23542 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23543 if (SWIG_arg_fail(4)) SWIG_fail;
23544 if (arg4 == NULL) {
23545 SWIG_null_ref("wxDateTime");
23546 }
23547 if (SWIG_arg_fail(4)) SWIG_fail;
23548 }
23549 }
23550 {
23551 PyThreadState* __tstate = wxPyBeginAllowThreads();
23552 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23553
23554 wxPyEndAllowThreads(__tstate);
23555 if (PyErr_Occurred()) SWIG_fail;
23556 }
23557 {
23558 resultobj = SWIG_From_int((int)(result));
23559 }
23560 {
23561 if (temp2)
23562 delete arg2;
23563 }
23564 {
23565 if (temp3)
23566 delete arg3;
23567 }
23568 return resultobj;
23569 fail:
23570 {
23571 if (temp2)
23572 delete arg2;
23573 }
23574 {
23575 if (temp3)
23576 delete arg3;
23577 }
23578 return NULL;
23579 }
23580
23581
23582 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23583 PyObject *resultobj;
23584 wxDateTime *arg1 = (wxDateTime *) 0 ;
23585 wxString *arg2 = 0 ;
23586 int result;
23587 bool temp2 = false ;
23588 PyObject * obj0 = 0 ;
23589 PyObject * obj1 = 0 ;
23590 char *kwnames[] = {
23591 (char *) "self",(char *) "datetime", NULL
23592 };
23593
23594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23596 if (SWIG_arg_fail(1)) SWIG_fail;
23597 {
23598 arg2 = wxString_in_helper(obj1);
23599 if (arg2 == NULL) SWIG_fail;
23600 temp2 = true;
23601 }
23602 {
23603 PyThreadState* __tstate = wxPyBeginAllowThreads();
23604 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23605
23606 wxPyEndAllowThreads(__tstate);
23607 if (PyErr_Occurred()) SWIG_fail;
23608 }
23609 {
23610 resultobj = SWIG_From_int((int)(result));
23611 }
23612 {
23613 if (temp2)
23614 delete arg2;
23615 }
23616 return resultobj;
23617 fail:
23618 {
23619 if (temp2)
23620 delete arg2;
23621 }
23622 return NULL;
23623 }
23624
23625
23626 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23627 PyObject *resultobj;
23628 wxDateTime *arg1 = (wxDateTime *) 0 ;
23629 wxString *arg2 = 0 ;
23630 int result;
23631 bool temp2 = false ;
23632 PyObject * obj0 = 0 ;
23633 PyObject * obj1 = 0 ;
23634 char *kwnames[] = {
23635 (char *) "self",(char *) "date", NULL
23636 };
23637
23638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23640 if (SWIG_arg_fail(1)) SWIG_fail;
23641 {
23642 arg2 = wxString_in_helper(obj1);
23643 if (arg2 == NULL) SWIG_fail;
23644 temp2 = true;
23645 }
23646 {
23647 PyThreadState* __tstate = wxPyBeginAllowThreads();
23648 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23649
23650 wxPyEndAllowThreads(__tstate);
23651 if (PyErr_Occurred()) SWIG_fail;
23652 }
23653 {
23654 resultobj = SWIG_From_int((int)(result));
23655 }
23656 {
23657 if (temp2)
23658 delete arg2;
23659 }
23660 return resultobj;
23661 fail:
23662 {
23663 if (temp2)
23664 delete arg2;
23665 }
23666 return NULL;
23667 }
23668
23669
23670 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23671 PyObject *resultobj;
23672 wxDateTime *arg1 = (wxDateTime *) 0 ;
23673 wxString *arg2 = 0 ;
23674 int result;
23675 bool temp2 = false ;
23676 PyObject * obj0 = 0 ;
23677 PyObject * obj1 = 0 ;
23678 char *kwnames[] = {
23679 (char *) "self",(char *) "time", NULL
23680 };
23681
23682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23684 if (SWIG_arg_fail(1)) SWIG_fail;
23685 {
23686 arg2 = wxString_in_helper(obj1);
23687 if (arg2 == NULL) SWIG_fail;
23688 temp2 = true;
23689 }
23690 {
23691 PyThreadState* __tstate = wxPyBeginAllowThreads();
23692 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23693
23694 wxPyEndAllowThreads(__tstate);
23695 if (PyErr_Occurred()) SWIG_fail;
23696 }
23697 {
23698 resultobj = SWIG_From_int((int)(result));
23699 }
23700 {
23701 if (temp2)
23702 delete arg2;
23703 }
23704 return resultobj;
23705 fail:
23706 {
23707 if (temp2)
23708 delete arg2;
23709 }
23710 return NULL;
23711 }
23712
23713
23714 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23715 PyObject *resultobj;
23716 wxDateTime *arg1 = (wxDateTime *) 0 ;
23717 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23718 wxString *arg2 = (wxString *) &arg2_defvalue ;
23719 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23720 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23721 wxString result;
23722 bool temp2 = false ;
23723 bool temp3 = false ;
23724 PyObject * obj0 = 0 ;
23725 PyObject * obj1 = 0 ;
23726 PyObject * obj2 = 0 ;
23727 char *kwnames[] = {
23728 (char *) "self",(char *) "format",(char *) "tz", NULL
23729 };
23730
23731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23733 if (SWIG_arg_fail(1)) SWIG_fail;
23734 if (obj1) {
23735 {
23736 arg2 = wxString_in_helper(obj1);
23737 if (arg2 == NULL) SWIG_fail;
23738 temp2 = true;
23739 }
23740 }
23741 if (obj2) {
23742 {
23743 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23744 temp3 = true;
23745 }
23746 }
23747 {
23748 PyThreadState* __tstate = wxPyBeginAllowThreads();
23749 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23750
23751 wxPyEndAllowThreads(__tstate);
23752 if (PyErr_Occurred()) SWIG_fail;
23753 }
23754 {
23755 #if wxUSE_UNICODE
23756 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23757 #else
23758 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23759 #endif
23760 }
23761 {
23762 if (temp2)
23763 delete arg2;
23764 }
23765 {
23766 if (temp3) delete arg3;
23767 }
23768 return resultobj;
23769 fail:
23770 {
23771 if (temp2)
23772 delete arg2;
23773 }
23774 {
23775 if (temp3) delete arg3;
23776 }
23777 return NULL;
23778 }
23779
23780
23781 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23782 PyObject *resultobj;
23783 wxDateTime *arg1 = (wxDateTime *) 0 ;
23784 wxString result;
23785 PyObject * obj0 = 0 ;
23786 char *kwnames[] = {
23787 (char *) "self", NULL
23788 };
23789
23790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23792 if (SWIG_arg_fail(1)) SWIG_fail;
23793 {
23794 PyThreadState* __tstate = wxPyBeginAllowThreads();
23795 result = ((wxDateTime const *)arg1)->FormatDate();
23796
23797 wxPyEndAllowThreads(__tstate);
23798 if (PyErr_Occurred()) SWIG_fail;
23799 }
23800 {
23801 #if wxUSE_UNICODE
23802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23803 #else
23804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23805 #endif
23806 }
23807 return resultobj;
23808 fail:
23809 return NULL;
23810 }
23811
23812
23813 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23814 PyObject *resultobj;
23815 wxDateTime *arg1 = (wxDateTime *) 0 ;
23816 wxString result;
23817 PyObject * obj0 = 0 ;
23818 char *kwnames[] = {
23819 (char *) "self", NULL
23820 };
23821
23822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23824 if (SWIG_arg_fail(1)) SWIG_fail;
23825 {
23826 PyThreadState* __tstate = wxPyBeginAllowThreads();
23827 result = ((wxDateTime const *)arg1)->FormatTime();
23828
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 {
23833 #if wxUSE_UNICODE
23834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23835 #else
23836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23837 #endif
23838 }
23839 return resultobj;
23840 fail:
23841 return NULL;
23842 }
23843
23844
23845 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23846 PyObject *resultobj;
23847 wxDateTime *arg1 = (wxDateTime *) 0 ;
23848 wxString result;
23849 PyObject * obj0 = 0 ;
23850 char *kwnames[] = {
23851 (char *) "self", NULL
23852 };
23853
23854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23856 if (SWIG_arg_fail(1)) SWIG_fail;
23857 {
23858 PyThreadState* __tstate = wxPyBeginAllowThreads();
23859 result = ((wxDateTime const *)arg1)->FormatISODate();
23860
23861 wxPyEndAllowThreads(__tstate);
23862 if (PyErr_Occurred()) SWIG_fail;
23863 }
23864 {
23865 #if wxUSE_UNICODE
23866 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23867 #else
23868 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23869 #endif
23870 }
23871 return resultobj;
23872 fail:
23873 return NULL;
23874 }
23875
23876
23877 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23878 PyObject *resultobj;
23879 wxDateTime *arg1 = (wxDateTime *) 0 ;
23880 wxString result;
23881 PyObject * obj0 = 0 ;
23882 char *kwnames[] = {
23883 (char *) "self", NULL
23884 };
23885
23886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23888 if (SWIG_arg_fail(1)) SWIG_fail;
23889 {
23890 PyThreadState* __tstate = wxPyBeginAllowThreads();
23891 result = ((wxDateTime const *)arg1)->FormatISOTime();
23892
23893 wxPyEndAllowThreads(__tstate);
23894 if (PyErr_Occurred()) SWIG_fail;
23895 }
23896 {
23897 #if wxUSE_UNICODE
23898 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23899 #else
23900 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23901 #endif
23902 }
23903 return resultobj;
23904 fail:
23905 return NULL;
23906 }
23907
23908
23909 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23910 PyObject *obj;
23911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23912 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23913 Py_INCREF(obj);
23914 return Py_BuildValue((char *)"");
23915 }
23916 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23917 PyObject *resultobj;
23918 long arg1 ;
23919 wxTimeSpan result;
23920 PyObject * obj0 = 0 ;
23921 char *kwnames[] = {
23922 (char *) "sec", NULL
23923 };
23924
23925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23926 {
23927 arg1 = (long)(SWIG_As_long(obj0));
23928 if (SWIG_arg_fail(1)) SWIG_fail;
23929 }
23930 {
23931 PyThreadState* __tstate = wxPyBeginAllowThreads();
23932 result = wxTimeSpan::Seconds(arg1);
23933
23934 wxPyEndAllowThreads(__tstate);
23935 if (PyErr_Occurred()) SWIG_fail;
23936 }
23937 {
23938 wxTimeSpan * resultptr;
23939 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23941 }
23942 return resultobj;
23943 fail:
23944 return NULL;
23945 }
23946
23947
23948 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23949 PyObject *resultobj;
23950 wxTimeSpan result;
23951 char *kwnames[] = {
23952 NULL
23953 };
23954
23955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23956 {
23957 PyThreadState* __tstate = wxPyBeginAllowThreads();
23958 result = wxTimeSpan::Second();
23959
23960 wxPyEndAllowThreads(__tstate);
23961 if (PyErr_Occurred()) SWIG_fail;
23962 }
23963 {
23964 wxTimeSpan * resultptr;
23965 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23966 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23967 }
23968 return resultobj;
23969 fail:
23970 return NULL;
23971 }
23972
23973
23974 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23975 PyObject *resultobj;
23976 long arg1 ;
23977 wxTimeSpan result;
23978 PyObject * obj0 = 0 ;
23979 char *kwnames[] = {
23980 (char *) "min", NULL
23981 };
23982
23983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23984 {
23985 arg1 = (long)(SWIG_As_long(obj0));
23986 if (SWIG_arg_fail(1)) SWIG_fail;
23987 }
23988 {
23989 PyThreadState* __tstate = wxPyBeginAllowThreads();
23990 result = wxTimeSpan::Minutes(arg1);
23991
23992 wxPyEndAllowThreads(__tstate);
23993 if (PyErr_Occurred()) SWIG_fail;
23994 }
23995 {
23996 wxTimeSpan * resultptr;
23997 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23998 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23999 }
24000 return resultobj;
24001 fail:
24002 return NULL;
24003 }
24004
24005
24006 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
24007 PyObject *resultobj;
24008 wxTimeSpan result;
24009 char *kwnames[] = {
24010 NULL
24011 };
24012
24013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
24014 {
24015 PyThreadState* __tstate = wxPyBeginAllowThreads();
24016 result = wxTimeSpan::Minute();
24017
24018 wxPyEndAllowThreads(__tstate);
24019 if (PyErr_Occurred()) SWIG_fail;
24020 }
24021 {
24022 wxTimeSpan * resultptr;
24023 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24024 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24025 }
24026 return resultobj;
24027 fail:
24028 return NULL;
24029 }
24030
24031
24032 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
24033 PyObject *resultobj;
24034 long arg1 ;
24035 wxTimeSpan result;
24036 PyObject * obj0 = 0 ;
24037 char *kwnames[] = {
24038 (char *) "hours", NULL
24039 };
24040
24041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
24042 {
24043 arg1 = (long)(SWIG_As_long(obj0));
24044 if (SWIG_arg_fail(1)) SWIG_fail;
24045 }
24046 {
24047 PyThreadState* __tstate = wxPyBeginAllowThreads();
24048 result = wxTimeSpan::Hours(arg1);
24049
24050 wxPyEndAllowThreads(__tstate);
24051 if (PyErr_Occurred()) SWIG_fail;
24052 }
24053 {
24054 wxTimeSpan * resultptr;
24055 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24056 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24057 }
24058 return resultobj;
24059 fail:
24060 return NULL;
24061 }
24062
24063
24064 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24065 PyObject *resultobj;
24066 wxTimeSpan result;
24067 char *kwnames[] = {
24068 NULL
24069 };
24070
24071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24072 {
24073 PyThreadState* __tstate = wxPyBeginAllowThreads();
24074 result = wxTimeSpan::Hour();
24075
24076 wxPyEndAllowThreads(__tstate);
24077 if (PyErr_Occurred()) SWIG_fail;
24078 }
24079 {
24080 wxTimeSpan * resultptr;
24081 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24082 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24083 }
24084 return resultobj;
24085 fail:
24086 return NULL;
24087 }
24088
24089
24090 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24091 PyObject *resultobj;
24092 long arg1 ;
24093 wxTimeSpan result;
24094 PyObject * obj0 = 0 ;
24095 char *kwnames[] = {
24096 (char *) "days", NULL
24097 };
24098
24099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24100 {
24101 arg1 = (long)(SWIG_As_long(obj0));
24102 if (SWIG_arg_fail(1)) SWIG_fail;
24103 }
24104 {
24105 PyThreadState* __tstate = wxPyBeginAllowThreads();
24106 result = wxTimeSpan::Days(arg1);
24107
24108 wxPyEndAllowThreads(__tstate);
24109 if (PyErr_Occurred()) SWIG_fail;
24110 }
24111 {
24112 wxTimeSpan * resultptr;
24113 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24114 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24115 }
24116 return resultobj;
24117 fail:
24118 return NULL;
24119 }
24120
24121
24122 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24123 PyObject *resultobj;
24124 wxTimeSpan result;
24125 char *kwnames[] = {
24126 NULL
24127 };
24128
24129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24130 {
24131 PyThreadState* __tstate = wxPyBeginAllowThreads();
24132 result = wxTimeSpan::Day();
24133
24134 wxPyEndAllowThreads(__tstate);
24135 if (PyErr_Occurred()) SWIG_fail;
24136 }
24137 {
24138 wxTimeSpan * resultptr;
24139 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24140 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24141 }
24142 return resultobj;
24143 fail:
24144 return NULL;
24145 }
24146
24147
24148 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24149 PyObject *resultobj;
24150 long arg1 ;
24151 wxTimeSpan result;
24152 PyObject * obj0 = 0 ;
24153 char *kwnames[] = {
24154 (char *) "days", NULL
24155 };
24156
24157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24158 {
24159 arg1 = (long)(SWIG_As_long(obj0));
24160 if (SWIG_arg_fail(1)) SWIG_fail;
24161 }
24162 {
24163 PyThreadState* __tstate = wxPyBeginAllowThreads();
24164 result = wxTimeSpan::Weeks(arg1);
24165
24166 wxPyEndAllowThreads(__tstate);
24167 if (PyErr_Occurred()) SWIG_fail;
24168 }
24169 {
24170 wxTimeSpan * resultptr;
24171 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24172 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24173 }
24174 return resultobj;
24175 fail:
24176 return NULL;
24177 }
24178
24179
24180 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24181 PyObject *resultobj;
24182 wxTimeSpan result;
24183 char *kwnames[] = {
24184 NULL
24185 };
24186
24187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24188 {
24189 PyThreadState* __tstate = wxPyBeginAllowThreads();
24190 result = wxTimeSpan::Week();
24191
24192 wxPyEndAllowThreads(__tstate);
24193 if (PyErr_Occurred()) SWIG_fail;
24194 }
24195 {
24196 wxTimeSpan * resultptr;
24197 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24198 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24199 }
24200 return resultobj;
24201 fail:
24202 return NULL;
24203 }
24204
24205
24206 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24207 PyObject *resultobj;
24208 long arg1 = (long) 0 ;
24209 long arg2 = (long) 0 ;
24210 long arg3 = (long) 0 ;
24211 long arg4 = (long) 0 ;
24212 wxTimeSpan *result;
24213 PyObject * obj0 = 0 ;
24214 PyObject * obj1 = 0 ;
24215 PyObject * obj2 = 0 ;
24216 PyObject * obj3 = 0 ;
24217 char *kwnames[] = {
24218 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24219 };
24220
24221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24222 if (obj0) {
24223 {
24224 arg1 = (long)(SWIG_As_long(obj0));
24225 if (SWIG_arg_fail(1)) SWIG_fail;
24226 }
24227 }
24228 if (obj1) {
24229 {
24230 arg2 = (long)(SWIG_As_long(obj1));
24231 if (SWIG_arg_fail(2)) SWIG_fail;
24232 }
24233 }
24234 if (obj2) {
24235 {
24236 arg3 = (long)(SWIG_As_long(obj2));
24237 if (SWIG_arg_fail(3)) SWIG_fail;
24238 }
24239 }
24240 if (obj3) {
24241 {
24242 arg4 = (long)(SWIG_As_long(obj3));
24243 if (SWIG_arg_fail(4)) SWIG_fail;
24244 }
24245 }
24246 {
24247 PyThreadState* __tstate = wxPyBeginAllowThreads();
24248 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24249
24250 wxPyEndAllowThreads(__tstate);
24251 if (PyErr_Occurred()) SWIG_fail;
24252 }
24253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24254 return resultobj;
24255 fail:
24256 return NULL;
24257 }
24258
24259
24260 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24261 PyObject *resultobj;
24262 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24263 PyObject * obj0 = 0 ;
24264 char *kwnames[] = {
24265 (char *) "self", NULL
24266 };
24267
24268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24270 if (SWIG_arg_fail(1)) SWIG_fail;
24271 {
24272 PyThreadState* __tstate = wxPyBeginAllowThreads();
24273 delete arg1;
24274
24275 wxPyEndAllowThreads(__tstate);
24276 if (PyErr_Occurred()) SWIG_fail;
24277 }
24278 Py_INCREF(Py_None); resultobj = Py_None;
24279 return resultobj;
24280 fail:
24281 return NULL;
24282 }
24283
24284
24285 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24286 PyObject *resultobj;
24287 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24288 wxTimeSpan *arg2 = 0 ;
24289 wxTimeSpan *result;
24290 PyObject * obj0 = 0 ;
24291 PyObject * obj1 = 0 ;
24292 char *kwnames[] = {
24293 (char *) "self",(char *) "diff", NULL
24294 };
24295
24296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24298 if (SWIG_arg_fail(1)) SWIG_fail;
24299 {
24300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24301 if (SWIG_arg_fail(2)) SWIG_fail;
24302 if (arg2 == NULL) {
24303 SWIG_null_ref("wxTimeSpan");
24304 }
24305 if (SWIG_arg_fail(2)) SWIG_fail;
24306 }
24307 {
24308 PyThreadState* __tstate = wxPyBeginAllowThreads();
24309 {
24310 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24311 result = (wxTimeSpan *) &_result_ref;
24312 }
24313
24314 wxPyEndAllowThreads(__tstate);
24315 if (PyErr_Occurred()) SWIG_fail;
24316 }
24317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24318 return resultobj;
24319 fail:
24320 return NULL;
24321 }
24322
24323
24324 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24325 PyObject *resultobj;
24326 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24327 wxTimeSpan *arg2 = 0 ;
24328 wxTimeSpan *result;
24329 PyObject * obj0 = 0 ;
24330 PyObject * obj1 = 0 ;
24331 char *kwnames[] = {
24332 (char *) "self",(char *) "diff", NULL
24333 };
24334
24335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24337 if (SWIG_arg_fail(1)) SWIG_fail;
24338 {
24339 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24340 if (SWIG_arg_fail(2)) SWIG_fail;
24341 if (arg2 == NULL) {
24342 SWIG_null_ref("wxTimeSpan");
24343 }
24344 if (SWIG_arg_fail(2)) SWIG_fail;
24345 }
24346 {
24347 PyThreadState* __tstate = wxPyBeginAllowThreads();
24348 {
24349 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24350 result = (wxTimeSpan *) &_result_ref;
24351 }
24352
24353 wxPyEndAllowThreads(__tstate);
24354 if (PyErr_Occurred()) SWIG_fail;
24355 }
24356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24357 return resultobj;
24358 fail:
24359 return NULL;
24360 }
24361
24362
24363 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24364 PyObject *resultobj;
24365 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24366 int arg2 ;
24367 wxTimeSpan *result;
24368 PyObject * obj0 = 0 ;
24369 PyObject * obj1 = 0 ;
24370 char *kwnames[] = {
24371 (char *) "self",(char *) "n", NULL
24372 };
24373
24374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24376 if (SWIG_arg_fail(1)) SWIG_fail;
24377 {
24378 arg2 = (int)(SWIG_As_int(obj1));
24379 if (SWIG_arg_fail(2)) SWIG_fail;
24380 }
24381 {
24382 PyThreadState* __tstate = wxPyBeginAllowThreads();
24383 {
24384 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24385 result = (wxTimeSpan *) &_result_ref;
24386 }
24387
24388 wxPyEndAllowThreads(__tstate);
24389 if (PyErr_Occurred()) SWIG_fail;
24390 }
24391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24392 return resultobj;
24393 fail:
24394 return NULL;
24395 }
24396
24397
24398 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24399 PyObject *resultobj;
24400 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24401 wxTimeSpan *result;
24402 PyObject * obj0 = 0 ;
24403 char *kwnames[] = {
24404 (char *) "self", NULL
24405 };
24406
24407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24409 if (SWIG_arg_fail(1)) SWIG_fail;
24410 {
24411 PyThreadState* __tstate = wxPyBeginAllowThreads();
24412 {
24413 wxTimeSpan &_result_ref = (arg1)->Neg();
24414 result = (wxTimeSpan *) &_result_ref;
24415 }
24416
24417 wxPyEndAllowThreads(__tstate);
24418 if (PyErr_Occurred()) SWIG_fail;
24419 }
24420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24421 return resultobj;
24422 fail:
24423 return NULL;
24424 }
24425
24426
24427 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24428 PyObject *resultobj;
24429 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24430 wxTimeSpan result;
24431 PyObject * obj0 = 0 ;
24432 char *kwnames[] = {
24433 (char *) "self", NULL
24434 };
24435
24436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24438 if (SWIG_arg_fail(1)) SWIG_fail;
24439 {
24440 PyThreadState* __tstate = wxPyBeginAllowThreads();
24441 result = ((wxTimeSpan const *)arg1)->Abs();
24442
24443 wxPyEndAllowThreads(__tstate);
24444 if (PyErr_Occurred()) SWIG_fail;
24445 }
24446 {
24447 wxTimeSpan * resultptr;
24448 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24449 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24450 }
24451 return resultobj;
24452 fail:
24453 return NULL;
24454 }
24455
24456
24457 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24458 PyObject *resultobj;
24459 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24460 wxTimeSpan *arg2 = 0 ;
24461 wxTimeSpan *result;
24462 PyObject * obj0 = 0 ;
24463 PyObject * obj1 = 0 ;
24464 char *kwnames[] = {
24465 (char *) "self",(char *) "diff", NULL
24466 };
24467
24468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24470 if (SWIG_arg_fail(1)) SWIG_fail;
24471 {
24472 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24473 if (SWIG_arg_fail(2)) SWIG_fail;
24474 if (arg2 == NULL) {
24475 SWIG_null_ref("wxTimeSpan");
24476 }
24477 if (SWIG_arg_fail(2)) SWIG_fail;
24478 }
24479 {
24480 PyThreadState* __tstate = wxPyBeginAllowThreads();
24481 {
24482 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24483 result = (wxTimeSpan *) &_result_ref;
24484 }
24485
24486 wxPyEndAllowThreads(__tstate);
24487 if (PyErr_Occurred()) SWIG_fail;
24488 }
24489 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24490 return resultobj;
24491 fail:
24492 return NULL;
24493 }
24494
24495
24496 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24497 PyObject *resultobj;
24498 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24499 wxTimeSpan *arg2 = 0 ;
24500 wxTimeSpan *result;
24501 PyObject * obj0 = 0 ;
24502 PyObject * obj1 = 0 ;
24503 char *kwnames[] = {
24504 (char *) "self",(char *) "diff", NULL
24505 };
24506
24507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24509 if (SWIG_arg_fail(1)) SWIG_fail;
24510 {
24511 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24512 if (SWIG_arg_fail(2)) SWIG_fail;
24513 if (arg2 == NULL) {
24514 SWIG_null_ref("wxTimeSpan");
24515 }
24516 if (SWIG_arg_fail(2)) SWIG_fail;
24517 }
24518 {
24519 PyThreadState* __tstate = wxPyBeginAllowThreads();
24520 {
24521 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24522 result = (wxTimeSpan *) &_result_ref;
24523 }
24524
24525 wxPyEndAllowThreads(__tstate);
24526 if (PyErr_Occurred()) SWIG_fail;
24527 }
24528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24529 return resultobj;
24530 fail:
24531 return NULL;
24532 }
24533
24534
24535 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24536 PyObject *resultobj;
24537 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24538 int arg2 ;
24539 wxTimeSpan *result;
24540 PyObject * obj0 = 0 ;
24541 PyObject * obj1 = 0 ;
24542 char *kwnames[] = {
24543 (char *) "self",(char *) "n", NULL
24544 };
24545
24546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24548 if (SWIG_arg_fail(1)) SWIG_fail;
24549 {
24550 arg2 = (int)(SWIG_As_int(obj1));
24551 if (SWIG_arg_fail(2)) SWIG_fail;
24552 }
24553 {
24554 PyThreadState* __tstate = wxPyBeginAllowThreads();
24555 {
24556 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24557 result = (wxTimeSpan *) &_result_ref;
24558 }
24559
24560 wxPyEndAllowThreads(__tstate);
24561 if (PyErr_Occurred()) SWIG_fail;
24562 }
24563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24564 return resultobj;
24565 fail:
24566 return NULL;
24567 }
24568
24569
24570 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24571 PyObject *resultobj;
24572 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24573 wxTimeSpan *result;
24574 PyObject * obj0 = 0 ;
24575 char *kwnames[] = {
24576 (char *) "self", NULL
24577 };
24578
24579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24581 if (SWIG_arg_fail(1)) SWIG_fail;
24582 {
24583 PyThreadState* __tstate = wxPyBeginAllowThreads();
24584 {
24585 wxTimeSpan &_result_ref = (arg1)->operator -();
24586 result = (wxTimeSpan *) &_result_ref;
24587 }
24588
24589 wxPyEndAllowThreads(__tstate);
24590 if (PyErr_Occurred()) SWIG_fail;
24591 }
24592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24593 return resultobj;
24594 fail:
24595 return NULL;
24596 }
24597
24598
24599 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24600 PyObject *resultobj;
24601 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24602 wxTimeSpan *arg2 = 0 ;
24603 wxTimeSpan result;
24604 PyObject * obj0 = 0 ;
24605 PyObject * obj1 = 0 ;
24606 char *kwnames[] = {
24607 (char *) "self",(char *) "other", NULL
24608 };
24609
24610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24612 if (SWIG_arg_fail(1)) SWIG_fail;
24613 {
24614 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24615 if (SWIG_arg_fail(2)) SWIG_fail;
24616 if (arg2 == NULL) {
24617 SWIG_null_ref("wxTimeSpan");
24618 }
24619 if (SWIG_arg_fail(2)) SWIG_fail;
24620 }
24621 {
24622 PyThreadState* __tstate = wxPyBeginAllowThreads();
24623 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24624
24625 wxPyEndAllowThreads(__tstate);
24626 if (PyErr_Occurred()) SWIG_fail;
24627 }
24628 {
24629 wxTimeSpan * resultptr;
24630 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24631 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24632 }
24633 return resultobj;
24634 fail:
24635 return NULL;
24636 }
24637
24638
24639 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24640 PyObject *resultobj;
24641 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24642 wxTimeSpan *arg2 = 0 ;
24643 wxTimeSpan result;
24644 PyObject * obj0 = 0 ;
24645 PyObject * obj1 = 0 ;
24646 char *kwnames[] = {
24647 (char *) "self",(char *) "other", NULL
24648 };
24649
24650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24652 if (SWIG_arg_fail(1)) SWIG_fail;
24653 {
24654 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24655 if (SWIG_arg_fail(2)) SWIG_fail;
24656 if (arg2 == NULL) {
24657 SWIG_null_ref("wxTimeSpan");
24658 }
24659 if (SWIG_arg_fail(2)) SWIG_fail;
24660 }
24661 {
24662 PyThreadState* __tstate = wxPyBeginAllowThreads();
24663 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24664
24665 wxPyEndAllowThreads(__tstate);
24666 if (PyErr_Occurred()) SWIG_fail;
24667 }
24668 {
24669 wxTimeSpan * resultptr;
24670 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24671 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24672 }
24673 return resultobj;
24674 fail:
24675 return NULL;
24676 }
24677
24678
24679 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24680 PyObject *resultobj;
24681 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24682 int arg2 ;
24683 wxTimeSpan result;
24684 PyObject * obj0 = 0 ;
24685 PyObject * obj1 = 0 ;
24686 char *kwnames[] = {
24687 (char *) "self",(char *) "n", NULL
24688 };
24689
24690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24692 if (SWIG_arg_fail(1)) SWIG_fail;
24693 {
24694 arg2 = (int)(SWIG_As_int(obj1));
24695 if (SWIG_arg_fail(2)) SWIG_fail;
24696 }
24697 {
24698 PyThreadState* __tstate = wxPyBeginAllowThreads();
24699 result = wxTimeSpan___mul__(arg1,arg2);
24700
24701 wxPyEndAllowThreads(__tstate);
24702 if (PyErr_Occurred()) SWIG_fail;
24703 }
24704 {
24705 wxTimeSpan * resultptr;
24706 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24707 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24708 }
24709 return resultobj;
24710 fail:
24711 return NULL;
24712 }
24713
24714
24715 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24716 PyObject *resultobj;
24717 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24718 int arg2 ;
24719 wxTimeSpan result;
24720 PyObject * obj0 = 0 ;
24721 PyObject * obj1 = 0 ;
24722 char *kwnames[] = {
24723 (char *) "self",(char *) "n", NULL
24724 };
24725
24726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24728 if (SWIG_arg_fail(1)) SWIG_fail;
24729 {
24730 arg2 = (int)(SWIG_As_int(obj1));
24731 if (SWIG_arg_fail(2)) SWIG_fail;
24732 }
24733 {
24734 PyThreadState* __tstate = wxPyBeginAllowThreads();
24735 result = wxTimeSpan___rmul__(arg1,arg2);
24736
24737 wxPyEndAllowThreads(__tstate);
24738 if (PyErr_Occurred()) SWIG_fail;
24739 }
24740 {
24741 wxTimeSpan * resultptr;
24742 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24743 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24744 }
24745 return resultobj;
24746 fail:
24747 return NULL;
24748 }
24749
24750
24751 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24752 PyObject *resultobj;
24753 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24754 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24755 bool result;
24756 PyObject * obj0 = 0 ;
24757 PyObject * obj1 = 0 ;
24758 char *kwnames[] = {
24759 (char *) "self",(char *) "other", NULL
24760 };
24761
24762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24764 if (SWIG_arg_fail(1)) SWIG_fail;
24765 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24766 if (SWIG_arg_fail(2)) SWIG_fail;
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24770
24771 wxPyEndAllowThreads(__tstate);
24772 if (PyErr_Occurred()) SWIG_fail;
24773 }
24774 {
24775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24776 }
24777 return resultobj;
24778 fail:
24779 return NULL;
24780 }
24781
24782
24783 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24784 PyObject *resultobj;
24785 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24786 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24787 bool result;
24788 PyObject * obj0 = 0 ;
24789 PyObject * obj1 = 0 ;
24790 char *kwnames[] = {
24791 (char *) "self",(char *) "other", NULL
24792 };
24793
24794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24796 if (SWIG_arg_fail(1)) SWIG_fail;
24797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24798 if (SWIG_arg_fail(2)) SWIG_fail;
24799 {
24800 PyThreadState* __tstate = wxPyBeginAllowThreads();
24801 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24802
24803 wxPyEndAllowThreads(__tstate);
24804 if (PyErr_Occurred()) SWIG_fail;
24805 }
24806 {
24807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24808 }
24809 return resultobj;
24810 fail:
24811 return NULL;
24812 }
24813
24814
24815 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24816 PyObject *resultobj;
24817 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24818 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24819 bool result;
24820 PyObject * obj0 = 0 ;
24821 PyObject * obj1 = 0 ;
24822 char *kwnames[] = {
24823 (char *) "self",(char *) "other", NULL
24824 };
24825
24826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24828 if (SWIG_arg_fail(1)) SWIG_fail;
24829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24830 if (SWIG_arg_fail(2)) SWIG_fail;
24831 {
24832 PyThreadState* __tstate = wxPyBeginAllowThreads();
24833 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24834
24835 wxPyEndAllowThreads(__tstate);
24836 if (PyErr_Occurred()) SWIG_fail;
24837 }
24838 {
24839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24840 }
24841 return resultobj;
24842 fail:
24843 return NULL;
24844 }
24845
24846
24847 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24848 PyObject *resultobj;
24849 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24850 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24851 bool result;
24852 PyObject * obj0 = 0 ;
24853 PyObject * obj1 = 0 ;
24854 char *kwnames[] = {
24855 (char *) "self",(char *) "other", NULL
24856 };
24857
24858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24860 if (SWIG_arg_fail(1)) SWIG_fail;
24861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24862 if (SWIG_arg_fail(2)) SWIG_fail;
24863 {
24864 PyThreadState* __tstate = wxPyBeginAllowThreads();
24865 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24866
24867 wxPyEndAllowThreads(__tstate);
24868 if (PyErr_Occurred()) SWIG_fail;
24869 }
24870 {
24871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24872 }
24873 return resultobj;
24874 fail:
24875 return NULL;
24876 }
24877
24878
24879 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24880 PyObject *resultobj;
24881 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24882 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24883 bool result;
24884 PyObject * obj0 = 0 ;
24885 PyObject * obj1 = 0 ;
24886 char *kwnames[] = {
24887 (char *) "self",(char *) "other", NULL
24888 };
24889
24890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24892 if (SWIG_arg_fail(1)) SWIG_fail;
24893 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24894 if (SWIG_arg_fail(2)) SWIG_fail;
24895 {
24896 PyThreadState* __tstate = wxPyBeginAllowThreads();
24897 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24898
24899 wxPyEndAllowThreads(__tstate);
24900 if (PyErr_Occurred()) SWIG_fail;
24901 }
24902 {
24903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24904 }
24905 return resultobj;
24906 fail:
24907 return NULL;
24908 }
24909
24910
24911 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24912 PyObject *resultobj;
24913 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24914 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24915 bool result;
24916 PyObject * obj0 = 0 ;
24917 PyObject * obj1 = 0 ;
24918 char *kwnames[] = {
24919 (char *) "self",(char *) "other", NULL
24920 };
24921
24922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24924 if (SWIG_arg_fail(1)) SWIG_fail;
24925 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24926 if (SWIG_arg_fail(2)) SWIG_fail;
24927 {
24928 PyThreadState* __tstate = wxPyBeginAllowThreads();
24929 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24930
24931 wxPyEndAllowThreads(__tstate);
24932 if (PyErr_Occurred()) SWIG_fail;
24933 }
24934 {
24935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24936 }
24937 return resultobj;
24938 fail:
24939 return NULL;
24940 }
24941
24942
24943 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24944 PyObject *resultobj;
24945 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24946 bool result;
24947 PyObject * obj0 = 0 ;
24948 char *kwnames[] = {
24949 (char *) "self", NULL
24950 };
24951
24952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24954 if (SWIG_arg_fail(1)) SWIG_fail;
24955 {
24956 PyThreadState* __tstate = wxPyBeginAllowThreads();
24957 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24958
24959 wxPyEndAllowThreads(__tstate);
24960 if (PyErr_Occurred()) SWIG_fail;
24961 }
24962 {
24963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24964 }
24965 return resultobj;
24966 fail:
24967 return NULL;
24968 }
24969
24970
24971 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24972 PyObject *resultobj;
24973 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24974 bool result;
24975 PyObject * obj0 = 0 ;
24976 char *kwnames[] = {
24977 (char *) "self", NULL
24978 };
24979
24980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24982 if (SWIG_arg_fail(1)) SWIG_fail;
24983 {
24984 PyThreadState* __tstate = wxPyBeginAllowThreads();
24985 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24986
24987 wxPyEndAllowThreads(__tstate);
24988 if (PyErr_Occurred()) SWIG_fail;
24989 }
24990 {
24991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24992 }
24993 return resultobj;
24994 fail:
24995 return NULL;
24996 }
24997
24998
24999 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
25000 PyObject *resultobj;
25001 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25002 bool result;
25003 PyObject * obj0 = 0 ;
25004 char *kwnames[] = {
25005 (char *) "self", NULL
25006 };
25007
25008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
25009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25010 if (SWIG_arg_fail(1)) SWIG_fail;
25011 {
25012 PyThreadState* __tstate = wxPyBeginAllowThreads();
25013 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
25014
25015 wxPyEndAllowThreads(__tstate);
25016 if (PyErr_Occurred()) SWIG_fail;
25017 }
25018 {
25019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25020 }
25021 return resultobj;
25022 fail:
25023 return NULL;
25024 }
25025
25026
25027 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
25028 PyObject *resultobj;
25029 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25030 wxTimeSpan *arg2 = 0 ;
25031 bool result;
25032 PyObject * obj0 = 0 ;
25033 PyObject * obj1 = 0 ;
25034 char *kwnames[] = {
25035 (char *) "self",(char *) "ts", NULL
25036 };
25037
25038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
25039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25040 if (SWIG_arg_fail(1)) SWIG_fail;
25041 {
25042 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25043 if (SWIG_arg_fail(2)) SWIG_fail;
25044 if (arg2 == NULL) {
25045 SWIG_null_ref("wxTimeSpan");
25046 }
25047 if (SWIG_arg_fail(2)) SWIG_fail;
25048 }
25049 {
25050 PyThreadState* __tstate = wxPyBeginAllowThreads();
25051 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
25052
25053 wxPyEndAllowThreads(__tstate);
25054 if (PyErr_Occurred()) SWIG_fail;
25055 }
25056 {
25057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25058 }
25059 return resultobj;
25060 fail:
25061 return NULL;
25062 }
25063
25064
25065 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25066 PyObject *resultobj;
25067 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25068 wxTimeSpan *arg2 = 0 ;
25069 bool result;
25070 PyObject * obj0 = 0 ;
25071 PyObject * obj1 = 0 ;
25072 char *kwnames[] = {
25073 (char *) "self",(char *) "ts", NULL
25074 };
25075
25076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25078 if (SWIG_arg_fail(1)) SWIG_fail;
25079 {
25080 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25081 if (SWIG_arg_fail(2)) SWIG_fail;
25082 if (arg2 == NULL) {
25083 SWIG_null_ref("wxTimeSpan");
25084 }
25085 if (SWIG_arg_fail(2)) SWIG_fail;
25086 }
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25090
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 {
25095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25096 }
25097 return resultobj;
25098 fail:
25099 return NULL;
25100 }
25101
25102
25103 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25104 PyObject *resultobj;
25105 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25106 wxTimeSpan *arg2 = 0 ;
25107 bool result;
25108 PyObject * obj0 = 0 ;
25109 PyObject * obj1 = 0 ;
25110 char *kwnames[] = {
25111 (char *) "self",(char *) "t", NULL
25112 };
25113
25114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25116 if (SWIG_arg_fail(1)) SWIG_fail;
25117 {
25118 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25119 if (SWIG_arg_fail(2)) SWIG_fail;
25120 if (arg2 == NULL) {
25121 SWIG_null_ref("wxTimeSpan");
25122 }
25123 if (SWIG_arg_fail(2)) SWIG_fail;
25124 }
25125 {
25126 PyThreadState* __tstate = wxPyBeginAllowThreads();
25127 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25128
25129 wxPyEndAllowThreads(__tstate);
25130 if (PyErr_Occurred()) SWIG_fail;
25131 }
25132 {
25133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25134 }
25135 return resultobj;
25136 fail:
25137 return NULL;
25138 }
25139
25140
25141 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25142 PyObject *resultobj;
25143 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25144 int result;
25145 PyObject * obj0 = 0 ;
25146 char *kwnames[] = {
25147 (char *) "self", NULL
25148 };
25149
25150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25152 if (SWIG_arg_fail(1)) SWIG_fail;
25153 {
25154 PyThreadState* __tstate = wxPyBeginAllowThreads();
25155 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25156
25157 wxPyEndAllowThreads(__tstate);
25158 if (PyErr_Occurred()) SWIG_fail;
25159 }
25160 {
25161 resultobj = SWIG_From_int((int)(result));
25162 }
25163 return resultobj;
25164 fail:
25165 return NULL;
25166 }
25167
25168
25169 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25170 PyObject *resultobj;
25171 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25172 int result;
25173 PyObject * obj0 = 0 ;
25174 char *kwnames[] = {
25175 (char *) "self", NULL
25176 };
25177
25178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25180 if (SWIG_arg_fail(1)) SWIG_fail;
25181 {
25182 PyThreadState* __tstate = wxPyBeginAllowThreads();
25183 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25184
25185 wxPyEndAllowThreads(__tstate);
25186 if (PyErr_Occurred()) SWIG_fail;
25187 }
25188 {
25189 resultobj = SWIG_From_int((int)(result));
25190 }
25191 return resultobj;
25192 fail:
25193 return NULL;
25194 }
25195
25196
25197 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25198 PyObject *resultobj;
25199 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25200 int result;
25201 PyObject * obj0 = 0 ;
25202 char *kwnames[] = {
25203 (char *) "self", NULL
25204 };
25205
25206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25208 if (SWIG_arg_fail(1)) SWIG_fail;
25209 {
25210 PyThreadState* __tstate = wxPyBeginAllowThreads();
25211 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25212
25213 wxPyEndAllowThreads(__tstate);
25214 if (PyErr_Occurred()) SWIG_fail;
25215 }
25216 {
25217 resultobj = SWIG_From_int((int)(result));
25218 }
25219 return resultobj;
25220 fail:
25221 return NULL;
25222 }
25223
25224
25225 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25226 PyObject *resultobj;
25227 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25228 int result;
25229 PyObject * obj0 = 0 ;
25230 char *kwnames[] = {
25231 (char *) "self", NULL
25232 };
25233
25234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25236 if (SWIG_arg_fail(1)) SWIG_fail;
25237 {
25238 PyThreadState* __tstate = wxPyBeginAllowThreads();
25239 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25240
25241 wxPyEndAllowThreads(__tstate);
25242 if (PyErr_Occurred()) SWIG_fail;
25243 }
25244 {
25245 resultobj = SWIG_From_int((int)(result));
25246 }
25247 return resultobj;
25248 fail:
25249 return NULL;
25250 }
25251
25252
25253 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25254 PyObject *resultobj;
25255 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25256 wxLongLong result;
25257 PyObject * obj0 = 0 ;
25258 char *kwnames[] = {
25259 (char *) "self", NULL
25260 };
25261
25262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25264 if (SWIG_arg_fail(1)) SWIG_fail;
25265 {
25266 PyThreadState* __tstate = wxPyBeginAllowThreads();
25267 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25268
25269 wxPyEndAllowThreads(__tstate);
25270 if (PyErr_Occurred()) SWIG_fail;
25271 }
25272 {
25273 PyObject *hi, *lo, *shifter, *shifted;
25274 hi = PyLong_FromLong( (&result)->GetHi() );
25275 lo = PyLong_FromLong( (&result)->GetLo() );
25276 shifter = PyLong_FromLong(32);
25277 shifted = PyNumber_Lshift(hi, shifter);
25278 resultobj = PyNumber_Or(shifted, lo);
25279 Py_DECREF(hi);
25280 Py_DECREF(lo);
25281 Py_DECREF(shifter);
25282 Py_DECREF(shifted);
25283 }
25284 return resultobj;
25285 fail:
25286 return NULL;
25287 }
25288
25289
25290 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25291 PyObject *resultobj;
25292 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25293 wxLongLong result;
25294 PyObject * obj0 = 0 ;
25295 char *kwnames[] = {
25296 (char *) "self", NULL
25297 };
25298
25299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25301 if (SWIG_arg_fail(1)) SWIG_fail;
25302 {
25303 PyThreadState* __tstate = wxPyBeginAllowThreads();
25304 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25305
25306 wxPyEndAllowThreads(__tstate);
25307 if (PyErr_Occurred()) SWIG_fail;
25308 }
25309 {
25310 PyObject *hi, *lo, *shifter, *shifted;
25311 hi = PyLong_FromLong( (&result)->GetHi() );
25312 lo = PyLong_FromLong( (&result)->GetLo() );
25313 shifter = PyLong_FromLong(32);
25314 shifted = PyNumber_Lshift(hi, shifter);
25315 resultobj = PyNumber_Or(shifted, lo);
25316 Py_DECREF(hi);
25317 Py_DECREF(lo);
25318 Py_DECREF(shifter);
25319 Py_DECREF(shifted);
25320 }
25321 return resultobj;
25322 fail:
25323 return NULL;
25324 }
25325
25326
25327 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25328 PyObject *resultobj;
25329 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25330 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25331 wxString *arg2 = (wxString *) &arg2_defvalue ;
25332 wxString result;
25333 bool temp2 = false ;
25334 PyObject * obj0 = 0 ;
25335 PyObject * obj1 = 0 ;
25336 char *kwnames[] = {
25337 (char *) "self",(char *) "format", NULL
25338 };
25339
25340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25342 if (SWIG_arg_fail(1)) SWIG_fail;
25343 if (obj1) {
25344 {
25345 arg2 = wxString_in_helper(obj1);
25346 if (arg2 == NULL) SWIG_fail;
25347 temp2 = true;
25348 }
25349 }
25350 {
25351 PyThreadState* __tstate = wxPyBeginAllowThreads();
25352 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25353
25354 wxPyEndAllowThreads(__tstate);
25355 if (PyErr_Occurred()) SWIG_fail;
25356 }
25357 {
25358 #if wxUSE_UNICODE
25359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25360 #else
25361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25362 #endif
25363 }
25364 {
25365 if (temp2)
25366 delete arg2;
25367 }
25368 return resultobj;
25369 fail:
25370 {
25371 if (temp2)
25372 delete arg2;
25373 }
25374 return NULL;
25375 }
25376
25377
25378 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25379 PyObject *obj;
25380 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25381 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25382 Py_INCREF(obj);
25383 return Py_BuildValue((char *)"");
25384 }
25385 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25386 PyObject *resultobj;
25387 int arg1 = (int) 0 ;
25388 int arg2 = (int) 0 ;
25389 int arg3 = (int) 0 ;
25390 int arg4 = (int) 0 ;
25391 wxDateSpan *result;
25392 PyObject * obj0 = 0 ;
25393 PyObject * obj1 = 0 ;
25394 PyObject * obj2 = 0 ;
25395 PyObject * obj3 = 0 ;
25396 char *kwnames[] = {
25397 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25398 };
25399
25400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25401 if (obj0) {
25402 {
25403 arg1 = (int)(SWIG_As_int(obj0));
25404 if (SWIG_arg_fail(1)) SWIG_fail;
25405 }
25406 }
25407 if (obj1) {
25408 {
25409 arg2 = (int)(SWIG_As_int(obj1));
25410 if (SWIG_arg_fail(2)) SWIG_fail;
25411 }
25412 }
25413 if (obj2) {
25414 {
25415 arg3 = (int)(SWIG_As_int(obj2));
25416 if (SWIG_arg_fail(3)) SWIG_fail;
25417 }
25418 }
25419 if (obj3) {
25420 {
25421 arg4 = (int)(SWIG_As_int(obj3));
25422 if (SWIG_arg_fail(4)) SWIG_fail;
25423 }
25424 }
25425 {
25426 PyThreadState* __tstate = wxPyBeginAllowThreads();
25427 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25428
25429 wxPyEndAllowThreads(__tstate);
25430 if (PyErr_Occurred()) SWIG_fail;
25431 }
25432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25433 return resultobj;
25434 fail:
25435 return NULL;
25436 }
25437
25438
25439 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25440 PyObject *resultobj;
25441 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25442 PyObject * obj0 = 0 ;
25443 char *kwnames[] = {
25444 (char *) "self", NULL
25445 };
25446
25447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25449 if (SWIG_arg_fail(1)) SWIG_fail;
25450 {
25451 PyThreadState* __tstate = wxPyBeginAllowThreads();
25452 delete arg1;
25453
25454 wxPyEndAllowThreads(__tstate);
25455 if (PyErr_Occurred()) SWIG_fail;
25456 }
25457 Py_INCREF(Py_None); resultobj = Py_None;
25458 return resultobj;
25459 fail:
25460 return NULL;
25461 }
25462
25463
25464 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25465 PyObject *resultobj;
25466 int arg1 ;
25467 wxDateSpan result;
25468 PyObject * obj0 = 0 ;
25469 char *kwnames[] = {
25470 (char *) "days", NULL
25471 };
25472
25473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25474 {
25475 arg1 = (int)(SWIG_As_int(obj0));
25476 if (SWIG_arg_fail(1)) SWIG_fail;
25477 }
25478 {
25479 PyThreadState* __tstate = wxPyBeginAllowThreads();
25480 result = wxDateSpan::Days(arg1);
25481
25482 wxPyEndAllowThreads(__tstate);
25483 if (PyErr_Occurred()) SWIG_fail;
25484 }
25485 {
25486 wxDateSpan * resultptr;
25487 resultptr = new wxDateSpan((wxDateSpan &)(result));
25488 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25489 }
25490 return resultobj;
25491 fail:
25492 return NULL;
25493 }
25494
25495
25496 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25497 PyObject *resultobj;
25498 wxDateSpan result;
25499 char *kwnames[] = {
25500 NULL
25501 };
25502
25503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25504 {
25505 PyThreadState* __tstate = wxPyBeginAllowThreads();
25506 result = wxDateSpan::Day();
25507
25508 wxPyEndAllowThreads(__tstate);
25509 if (PyErr_Occurred()) SWIG_fail;
25510 }
25511 {
25512 wxDateSpan * resultptr;
25513 resultptr = new wxDateSpan((wxDateSpan &)(result));
25514 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25515 }
25516 return resultobj;
25517 fail:
25518 return NULL;
25519 }
25520
25521
25522 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25523 PyObject *resultobj;
25524 int arg1 ;
25525 wxDateSpan result;
25526 PyObject * obj0 = 0 ;
25527 char *kwnames[] = {
25528 (char *) "weeks", NULL
25529 };
25530
25531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25532 {
25533 arg1 = (int)(SWIG_As_int(obj0));
25534 if (SWIG_arg_fail(1)) SWIG_fail;
25535 }
25536 {
25537 PyThreadState* __tstate = wxPyBeginAllowThreads();
25538 result = wxDateSpan::Weeks(arg1);
25539
25540 wxPyEndAllowThreads(__tstate);
25541 if (PyErr_Occurred()) SWIG_fail;
25542 }
25543 {
25544 wxDateSpan * resultptr;
25545 resultptr = new wxDateSpan((wxDateSpan &)(result));
25546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25547 }
25548 return resultobj;
25549 fail:
25550 return NULL;
25551 }
25552
25553
25554 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25555 PyObject *resultobj;
25556 wxDateSpan result;
25557 char *kwnames[] = {
25558 NULL
25559 };
25560
25561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25562 {
25563 PyThreadState* __tstate = wxPyBeginAllowThreads();
25564 result = wxDateSpan::Week();
25565
25566 wxPyEndAllowThreads(__tstate);
25567 if (PyErr_Occurred()) SWIG_fail;
25568 }
25569 {
25570 wxDateSpan * resultptr;
25571 resultptr = new wxDateSpan((wxDateSpan &)(result));
25572 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25573 }
25574 return resultobj;
25575 fail:
25576 return NULL;
25577 }
25578
25579
25580 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25581 PyObject *resultobj;
25582 int arg1 ;
25583 wxDateSpan result;
25584 PyObject * obj0 = 0 ;
25585 char *kwnames[] = {
25586 (char *) "mon", NULL
25587 };
25588
25589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25590 {
25591 arg1 = (int)(SWIG_As_int(obj0));
25592 if (SWIG_arg_fail(1)) SWIG_fail;
25593 }
25594 {
25595 PyThreadState* __tstate = wxPyBeginAllowThreads();
25596 result = wxDateSpan::Months(arg1);
25597
25598 wxPyEndAllowThreads(__tstate);
25599 if (PyErr_Occurred()) SWIG_fail;
25600 }
25601 {
25602 wxDateSpan * resultptr;
25603 resultptr = new wxDateSpan((wxDateSpan &)(result));
25604 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25605 }
25606 return resultobj;
25607 fail:
25608 return NULL;
25609 }
25610
25611
25612 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25613 PyObject *resultobj;
25614 wxDateSpan result;
25615 char *kwnames[] = {
25616 NULL
25617 };
25618
25619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25620 {
25621 PyThreadState* __tstate = wxPyBeginAllowThreads();
25622 result = wxDateSpan::Month();
25623
25624 wxPyEndAllowThreads(__tstate);
25625 if (PyErr_Occurred()) SWIG_fail;
25626 }
25627 {
25628 wxDateSpan * resultptr;
25629 resultptr = new wxDateSpan((wxDateSpan &)(result));
25630 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25631 }
25632 return resultobj;
25633 fail:
25634 return NULL;
25635 }
25636
25637
25638 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25639 PyObject *resultobj;
25640 int arg1 ;
25641 wxDateSpan result;
25642 PyObject * obj0 = 0 ;
25643 char *kwnames[] = {
25644 (char *) "years", NULL
25645 };
25646
25647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25648 {
25649 arg1 = (int)(SWIG_As_int(obj0));
25650 if (SWIG_arg_fail(1)) SWIG_fail;
25651 }
25652 {
25653 PyThreadState* __tstate = wxPyBeginAllowThreads();
25654 result = wxDateSpan::Years(arg1);
25655
25656 wxPyEndAllowThreads(__tstate);
25657 if (PyErr_Occurred()) SWIG_fail;
25658 }
25659 {
25660 wxDateSpan * resultptr;
25661 resultptr = new wxDateSpan((wxDateSpan &)(result));
25662 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25663 }
25664 return resultobj;
25665 fail:
25666 return NULL;
25667 }
25668
25669
25670 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25671 PyObject *resultobj;
25672 wxDateSpan result;
25673 char *kwnames[] = {
25674 NULL
25675 };
25676
25677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25678 {
25679 PyThreadState* __tstate = wxPyBeginAllowThreads();
25680 result = wxDateSpan::Year();
25681
25682 wxPyEndAllowThreads(__tstate);
25683 if (PyErr_Occurred()) SWIG_fail;
25684 }
25685 {
25686 wxDateSpan * resultptr;
25687 resultptr = new wxDateSpan((wxDateSpan &)(result));
25688 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25689 }
25690 return resultobj;
25691 fail:
25692 return NULL;
25693 }
25694
25695
25696 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25697 PyObject *resultobj;
25698 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25699 int arg2 ;
25700 wxDateSpan *result;
25701 PyObject * obj0 = 0 ;
25702 PyObject * obj1 = 0 ;
25703 char *kwnames[] = {
25704 (char *) "self",(char *) "n", NULL
25705 };
25706
25707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25709 if (SWIG_arg_fail(1)) SWIG_fail;
25710 {
25711 arg2 = (int)(SWIG_As_int(obj1));
25712 if (SWIG_arg_fail(2)) SWIG_fail;
25713 }
25714 {
25715 PyThreadState* __tstate = wxPyBeginAllowThreads();
25716 {
25717 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25718 result = (wxDateSpan *) &_result_ref;
25719 }
25720
25721 wxPyEndAllowThreads(__tstate);
25722 if (PyErr_Occurred()) SWIG_fail;
25723 }
25724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25725 return resultobj;
25726 fail:
25727 return NULL;
25728 }
25729
25730
25731 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25732 PyObject *resultobj;
25733 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25734 int arg2 ;
25735 wxDateSpan *result;
25736 PyObject * obj0 = 0 ;
25737 PyObject * obj1 = 0 ;
25738 char *kwnames[] = {
25739 (char *) "self",(char *) "n", NULL
25740 };
25741
25742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25744 if (SWIG_arg_fail(1)) SWIG_fail;
25745 {
25746 arg2 = (int)(SWIG_As_int(obj1));
25747 if (SWIG_arg_fail(2)) SWIG_fail;
25748 }
25749 {
25750 PyThreadState* __tstate = wxPyBeginAllowThreads();
25751 {
25752 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25753 result = (wxDateSpan *) &_result_ref;
25754 }
25755
25756 wxPyEndAllowThreads(__tstate);
25757 if (PyErr_Occurred()) SWIG_fail;
25758 }
25759 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25760 return resultobj;
25761 fail:
25762 return NULL;
25763 }
25764
25765
25766 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25767 PyObject *resultobj;
25768 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25769 int arg2 ;
25770 wxDateSpan *result;
25771 PyObject * obj0 = 0 ;
25772 PyObject * obj1 = 0 ;
25773 char *kwnames[] = {
25774 (char *) "self",(char *) "n", NULL
25775 };
25776
25777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25779 if (SWIG_arg_fail(1)) SWIG_fail;
25780 {
25781 arg2 = (int)(SWIG_As_int(obj1));
25782 if (SWIG_arg_fail(2)) SWIG_fail;
25783 }
25784 {
25785 PyThreadState* __tstate = wxPyBeginAllowThreads();
25786 {
25787 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25788 result = (wxDateSpan *) &_result_ref;
25789 }
25790
25791 wxPyEndAllowThreads(__tstate);
25792 if (PyErr_Occurred()) SWIG_fail;
25793 }
25794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25795 return resultobj;
25796 fail:
25797 return NULL;
25798 }
25799
25800
25801 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25802 PyObject *resultobj;
25803 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25804 int arg2 ;
25805 wxDateSpan *result;
25806 PyObject * obj0 = 0 ;
25807 PyObject * obj1 = 0 ;
25808 char *kwnames[] = {
25809 (char *) "self",(char *) "n", NULL
25810 };
25811
25812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25814 if (SWIG_arg_fail(1)) SWIG_fail;
25815 {
25816 arg2 = (int)(SWIG_As_int(obj1));
25817 if (SWIG_arg_fail(2)) SWIG_fail;
25818 }
25819 {
25820 PyThreadState* __tstate = wxPyBeginAllowThreads();
25821 {
25822 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25823 result = (wxDateSpan *) &_result_ref;
25824 }
25825
25826 wxPyEndAllowThreads(__tstate);
25827 if (PyErr_Occurred()) SWIG_fail;
25828 }
25829 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25830 return resultobj;
25831 fail:
25832 return NULL;
25833 }
25834
25835
25836 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25837 PyObject *resultobj;
25838 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25839 int result;
25840 PyObject * obj0 = 0 ;
25841 char *kwnames[] = {
25842 (char *) "self", NULL
25843 };
25844
25845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25847 if (SWIG_arg_fail(1)) SWIG_fail;
25848 {
25849 PyThreadState* __tstate = wxPyBeginAllowThreads();
25850 result = (int)((wxDateSpan const *)arg1)->GetYears();
25851
25852 wxPyEndAllowThreads(__tstate);
25853 if (PyErr_Occurred()) SWIG_fail;
25854 }
25855 {
25856 resultobj = SWIG_From_int((int)(result));
25857 }
25858 return resultobj;
25859 fail:
25860 return NULL;
25861 }
25862
25863
25864 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25865 PyObject *resultobj;
25866 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25867 int result;
25868 PyObject * obj0 = 0 ;
25869 char *kwnames[] = {
25870 (char *) "self", NULL
25871 };
25872
25873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25875 if (SWIG_arg_fail(1)) SWIG_fail;
25876 {
25877 PyThreadState* __tstate = wxPyBeginAllowThreads();
25878 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25879
25880 wxPyEndAllowThreads(__tstate);
25881 if (PyErr_Occurred()) SWIG_fail;
25882 }
25883 {
25884 resultobj = SWIG_From_int((int)(result));
25885 }
25886 return resultobj;
25887 fail:
25888 return NULL;
25889 }
25890
25891
25892 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25893 PyObject *resultobj;
25894 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25895 int result;
25896 PyObject * obj0 = 0 ;
25897 char *kwnames[] = {
25898 (char *) "self", NULL
25899 };
25900
25901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25903 if (SWIG_arg_fail(1)) SWIG_fail;
25904 {
25905 PyThreadState* __tstate = wxPyBeginAllowThreads();
25906 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25907
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 {
25912 resultobj = SWIG_From_int((int)(result));
25913 }
25914 return resultobj;
25915 fail:
25916 return NULL;
25917 }
25918
25919
25920 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25921 PyObject *resultobj;
25922 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25923 int result;
25924 PyObject * obj0 = 0 ;
25925 char *kwnames[] = {
25926 (char *) "self", NULL
25927 };
25928
25929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25931 if (SWIG_arg_fail(1)) SWIG_fail;
25932 {
25933 PyThreadState* __tstate = wxPyBeginAllowThreads();
25934 result = (int)((wxDateSpan const *)arg1)->GetDays();
25935
25936 wxPyEndAllowThreads(__tstate);
25937 if (PyErr_Occurred()) SWIG_fail;
25938 }
25939 {
25940 resultobj = SWIG_From_int((int)(result));
25941 }
25942 return resultobj;
25943 fail:
25944 return NULL;
25945 }
25946
25947
25948 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25949 PyObject *resultobj;
25950 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25951 int result;
25952 PyObject * obj0 = 0 ;
25953 char *kwnames[] = {
25954 (char *) "self", NULL
25955 };
25956
25957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25959 if (SWIG_arg_fail(1)) SWIG_fail;
25960 {
25961 PyThreadState* __tstate = wxPyBeginAllowThreads();
25962 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25963
25964 wxPyEndAllowThreads(__tstate);
25965 if (PyErr_Occurred()) SWIG_fail;
25966 }
25967 {
25968 resultobj = SWIG_From_int((int)(result));
25969 }
25970 return resultobj;
25971 fail:
25972 return NULL;
25973 }
25974
25975
25976 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25977 PyObject *resultobj;
25978 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25979 wxDateSpan *arg2 = 0 ;
25980 wxDateSpan *result;
25981 PyObject * obj0 = 0 ;
25982 PyObject * obj1 = 0 ;
25983 char *kwnames[] = {
25984 (char *) "self",(char *) "other", NULL
25985 };
25986
25987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25989 if (SWIG_arg_fail(1)) SWIG_fail;
25990 {
25991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25992 if (SWIG_arg_fail(2)) SWIG_fail;
25993 if (arg2 == NULL) {
25994 SWIG_null_ref("wxDateSpan");
25995 }
25996 if (SWIG_arg_fail(2)) SWIG_fail;
25997 }
25998 {
25999 PyThreadState* __tstate = wxPyBeginAllowThreads();
26000 {
26001 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
26002 result = (wxDateSpan *) &_result_ref;
26003 }
26004
26005 wxPyEndAllowThreads(__tstate);
26006 if (PyErr_Occurred()) SWIG_fail;
26007 }
26008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26009 return resultobj;
26010 fail:
26011 return NULL;
26012 }
26013
26014
26015 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
26016 PyObject *resultobj;
26017 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26018 wxDateSpan *arg2 = 0 ;
26019 wxDateSpan *result;
26020 PyObject * obj0 = 0 ;
26021 PyObject * obj1 = 0 ;
26022 char *kwnames[] = {
26023 (char *) "self",(char *) "other", NULL
26024 };
26025
26026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
26027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26028 if (SWIG_arg_fail(1)) SWIG_fail;
26029 {
26030 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26031 if (SWIG_arg_fail(2)) SWIG_fail;
26032 if (arg2 == NULL) {
26033 SWIG_null_ref("wxDateSpan");
26034 }
26035 if (SWIG_arg_fail(2)) SWIG_fail;
26036 }
26037 {
26038 PyThreadState* __tstate = wxPyBeginAllowThreads();
26039 {
26040 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26041 result = (wxDateSpan *) &_result_ref;
26042 }
26043
26044 wxPyEndAllowThreads(__tstate);
26045 if (PyErr_Occurred()) SWIG_fail;
26046 }
26047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26048 return resultobj;
26049 fail:
26050 return NULL;
26051 }
26052
26053
26054 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
26055 PyObject *resultobj;
26056 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26057 wxDateSpan *result;
26058 PyObject * obj0 = 0 ;
26059 char *kwnames[] = {
26060 (char *) "self", NULL
26061 };
26062
26063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26065 if (SWIG_arg_fail(1)) SWIG_fail;
26066 {
26067 PyThreadState* __tstate = wxPyBeginAllowThreads();
26068 {
26069 wxDateSpan &_result_ref = (arg1)->Neg();
26070 result = (wxDateSpan *) &_result_ref;
26071 }
26072
26073 wxPyEndAllowThreads(__tstate);
26074 if (PyErr_Occurred()) SWIG_fail;
26075 }
26076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26077 return resultobj;
26078 fail:
26079 return NULL;
26080 }
26081
26082
26083 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26084 PyObject *resultobj;
26085 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26086 int arg2 ;
26087 wxDateSpan *result;
26088 PyObject * obj0 = 0 ;
26089 PyObject * obj1 = 0 ;
26090 char *kwnames[] = {
26091 (char *) "self",(char *) "factor", NULL
26092 };
26093
26094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26096 if (SWIG_arg_fail(1)) SWIG_fail;
26097 {
26098 arg2 = (int)(SWIG_As_int(obj1));
26099 if (SWIG_arg_fail(2)) SWIG_fail;
26100 }
26101 {
26102 PyThreadState* __tstate = wxPyBeginAllowThreads();
26103 {
26104 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26105 result = (wxDateSpan *) &_result_ref;
26106 }
26107
26108 wxPyEndAllowThreads(__tstate);
26109 if (PyErr_Occurred()) SWIG_fail;
26110 }
26111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26112 return resultobj;
26113 fail:
26114 return NULL;
26115 }
26116
26117
26118 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26119 PyObject *resultobj;
26120 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26121 wxDateSpan *arg2 = 0 ;
26122 wxDateSpan *result;
26123 PyObject * obj0 = 0 ;
26124 PyObject * obj1 = 0 ;
26125 char *kwnames[] = {
26126 (char *) "self",(char *) "other", NULL
26127 };
26128
26129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26131 if (SWIG_arg_fail(1)) SWIG_fail;
26132 {
26133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26134 if (SWIG_arg_fail(2)) SWIG_fail;
26135 if (arg2 == NULL) {
26136 SWIG_null_ref("wxDateSpan");
26137 }
26138 if (SWIG_arg_fail(2)) SWIG_fail;
26139 }
26140 {
26141 PyThreadState* __tstate = wxPyBeginAllowThreads();
26142 {
26143 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26144 result = (wxDateSpan *) &_result_ref;
26145 }
26146
26147 wxPyEndAllowThreads(__tstate);
26148 if (PyErr_Occurred()) SWIG_fail;
26149 }
26150 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26151 return resultobj;
26152 fail:
26153 return NULL;
26154 }
26155
26156
26157 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26158 PyObject *resultobj;
26159 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26160 wxDateSpan *arg2 = 0 ;
26161 wxDateSpan *result;
26162 PyObject * obj0 = 0 ;
26163 PyObject * obj1 = 0 ;
26164 char *kwnames[] = {
26165 (char *) "self",(char *) "other", NULL
26166 };
26167
26168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26170 if (SWIG_arg_fail(1)) SWIG_fail;
26171 {
26172 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26173 if (SWIG_arg_fail(2)) SWIG_fail;
26174 if (arg2 == NULL) {
26175 SWIG_null_ref("wxDateSpan");
26176 }
26177 if (SWIG_arg_fail(2)) SWIG_fail;
26178 }
26179 {
26180 PyThreadState* __tstate = wxPyBeginAllowThreads();
26181 {
26182 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26183 result = (wxDateSpan *) &_result_ref;
26184 }
26185
26186 wxPyEndAllowThreads(__tstate);
26187 if (PyErr_Occurred()) SWIG_fail;
26188 }
26189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26190 return resultobj;
26191 fail:
26192 return NULL;
26193 }
26194
26195
26196 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26197 PyObject *resultobj;
26198 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26199 wxDateSpan *result;
26200 PyObject * obj0 = 0 ;
26201 char *kwnames[] = {
26202 (char *) "self", NULL
26203 };
26204
26205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26207 if (SWIG_arg_fail(1)) SWIG_fail;
26208 {
26209 PyThreadState* __tstate = wxPyBeginAllowThreads();
26210 {
26211 wxDateSpan &_result_ref = (arg1)->operator -();
26212 result = (wxDateSpan *) &_result_ref;
26213 }
26214
26215 wxPyEndAllowThreads(__tstate);
26216 if (PyErr_Occurred()) SWIG_fail;
26217 }
26218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26219 return resultobj;
26220 fail:
26221 return NULL;
26222 }
26223
26224
26225 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26226 PyObject *resultobj;
26227 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26228 int arg2 ;
26229 wxDateSpan *result;
26230 PyObject * obj0 = 0 ;
26231 PyObject * obj1 = 0 ;
26232 char *kwnames[] = {
26233 (char *) "self",(char *) "factor", NULL
26234 };
26235
26236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26238 if (SWIG_arg_fail(1)) SWIG_fail;
26239 {
26240 arg2 = (int)(SWIG_As_int(obj1));
26241 if (SWIG_arg_fail(2)) SWIG_fail;
26242 }
26243 {
26244 PyThreadState* __tstate = wxPyBeginAllowThreads();
26245 {
26246 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26247 result = (wxDateSpan *) &_result_ref;
26248 }
26249
26250 wxPyEndAllowThreads(__tstate);
26251 if (PyErr_Occurred()) SWIG_fail;
26252 }
26253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26254 return resultobj;
26255 fail:
26256 return NULL;
26257 }
26258
26259
26260 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26261 PyObject *resultobj;
26262 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26263 wxDateSpan *arg2 = 0 ;
26264 wxDateSpan result;
26265 PyObject * obj0 = 0 ;
26266 PyObject * obj1 = 0 ;
26267 char *kwnames[] = {
26268 (char *) "self",(char *) "other", NULL
26269 };
26270
26271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26273 if (SWIG_arg_fail(1)) SWIG_fail;
26274 {
26275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26276 if (SWIG_arg_fail(2)) SWIG_fail;
26277 if (arg2 == NULL) {
26278 SWIG_null_ref("wxDateSpan");
26279 }
26280 if (SWIG_arg_fail(2)) SWIG_fail;
26281 }
26282 {
26283 PyThreadState* __tstate = wxPyBeginAllowThreads();
26284 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26285
26286 wxPyEndAllowThreads(__tstate);
26287 if (PyErr_Occurred()) SWIG_fail;
26288 }
26289 {
26290 wxDateSpan * resultptr;
26291 resultptr = new wxDateSpan((wxDateSpan &)(result));
26292 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26293 }
26294 return resultobj;
26295 fail:
26296 return NULL;
26297 }
26298
26299
26300 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26301 PyObject *resultobj;
26302 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26303 wxDateSpan *arg2 = 0 ;
26304 wxDateSpan result;
26305 PyObject * obj0 = 0 ;
26306 PyObject * obj1 = 0 ;
26307 char *kwnames[] = {
26308 (char *) "self",(char *) "other", NULL
26309 };
26310
26311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26313 if (SWIG_arg_fail(1)) SWIG_fail;
26314 {
26315 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26316 if (SWIG_arg_fail(2)) SWIG_fail;
26317 if (arg2 == NULL) {
26318 SWIG_null_ref("wxDateSpan");
26319 }
26320 if (SWIG_arg_fail(2)) SWIG_fail;
26321 }
26322 {
26323 PyThreadState* __tstate = wxPyBeginAllowThreads();
26324 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26325
26326 wxPyEndAllowThreads(__tstate);
26327 if (PyErr_Occurred()) SWIG_fail;
26328 }
26329 {
26330 wxDateSpan * resultptr;
26331 resultptr = new wxDateSpan((wxDateSpan &)(result));
26332 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26333 }
26334 return resultobj;
26335 fail:
26336 return NULL;
26337 }
26338
26339
26340 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26341 PyObject *resultobj;
26342 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26343 int arg2 ;
26344 wxDateSpan result;
26345 PyObject * obj0 = 0 ;
26346 PyObject * obj1 = 0 ;
26347 char *kwnames[] = {
26348 (char *) "self",(char *) "n", NULL
26349 };
26350
26351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26353 if (SWIG_arg_fail(1)) SWIG_fail;
26354 {
26355 arg2 = (int)(SWIG_As_int(obj1));
26356 if (SWIG_arg_fail(2)) SWIG_fail;
26357 }
26358 {
26359 PyThreadState* __tstate = wxPyBeginAllowThreads();
26360 result = wxDateSpan___mul__(arg1,arg2);
26361
26362 wxPyEndAllowThreads(__tstate);
26363 if (PyErr_Occurred()) SWIG_fail;
26364 }
26365 {
26366 wxDateSpan * resultptr;
26367 resultptr = new wxDateSpan((wxDateSpan &)(result));
26368 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26369 }
26370 return resultobj;
26371 fail:
26372 return NULL;
26373 }
26374
26375
26376 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26377 PyObject *resultobj;
26378 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26379 int arg2 ;
26380 wxDateSpan result;
26381 PyObject * obj0 = 0 ;
26382 PyObject * obj1 = 0 ;
26383 char *kwnames[] = {
26384 (char *) "self",(char *) "n", NULL
26385 };
26386
26387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26389 if (SWIG_arg_fail(1)) SWIG_fail;
26390 {
26391 arg2 = (int)(SWIG_As_int(obj1));
26392 if (SWIG_arg_fail(2)) SWIG_fail;
26393 }
26394 {
26395 PyThreadState* __tstate = wxPyBeginAllowThreads();
26396 result = wxDateSpan___rmul__(arg1,arg2);
26397
26398 wxPyEndAllowThreads(__tstate);
26399 if (PyErr_Occurred()) SWIG_fail;
26400 }
26401 {
26402 wxDateSpan * resultptr;
26403 resultptr = new wxDateSpan((wxDateSpan &)(result));
26404 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26405 }
26406 return resultobj;
26407 fail:
26408 return NULL;
26409 }
26410
26411
26412 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26413 PyObject *resultobj;
26414 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26415 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26416 bool result;
26417 PyObject * obj0 = 0 ;
26418 PyObject * obj1 = 0 ;
26419 char *kwnames[] = {
26420 (char *) "self",(char *) "other", NULL
26421 };
26422
26423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26425 if (SWIG_arg_fail(1)) SWIG_fail;
26426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26427 if (SWIG_arg_fail(2)) SWIG_fail;
26428 {
26429 PyThreadState* __tstate = wxPyBeginAllowThreads();
26430 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26431
26432 wxPyEndAllowThreads(__tstate);
26433 if (PyErr_Occurred()) SWIG_fail;
26434 }
26435 {
26436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26437 }
26438 return resultobj;
26439 fail:
26440 return NULL;
26441 }
26442
26443
26444 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26445 PyObject *resultobj;
26446 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26447 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26448 bool result;
26449 PyObject * obj0 = 0 ;
26450 PyObject * obj1 = 0 ;
26451 char *kwnames[] = {
26452 (char *) "self",(char *) "other", NULL
26453 };
26454
26455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26457 if (SWIG_arg_fail(1)) SWIG_fail;
26458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26459 if (SWIG_arg_fail(2)) SWIG_fail;
26460 {
26461 PyThreadState* __tstate = wxPyBeginAllowThreads();
26462 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26463
26464 wxPyEndAllowThreads(__tstate);
26465 if (PyErr_Occurred()) SWIG_fail;
26466 }
26467 {
26468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26469 }
26470 return resultobj;
26471 fail:
26472 return NULL;
26473 }
26474
26475
26476 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26477 PyObject *obj;
26478 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26479 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26480 Py_INCREF(obj);
26481 return Py_BuildValue((char *)"");
26482 }
26483 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26484 PyObject *resultobj;
26485 long result;
26486 char *kwnames[] = {
26487 NULL
26488 };
26489
26490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26491 {
26492 PyThreadState* __tstate = wxPyBeginAllowThreads();
26493 result = (long)wxGetLocalTime();
26494
26495 wxPyEndAllowThreads(__tstate);
26496 if (PyErr_Occurred()) SWIG_fail;
26497 }
26498 {
26499 resultobj = SWIG_From_long((long)(result));
26500 }
26501 return resultobj;
26502 fail:
26503 return NULL;
26504 }
26505
26506
26507 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26508 PyObject *resultobj;
26509 long result;
26510 char *kwnames[] = {
26511 NULL
26512 };
26513
26514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26515 {
26516 PyThreadState* __tstate = wxPyBeginAllowThreads();
26517 result = (long)wxGetUTCTime();
26518
26519 wxPyEndAllowThreads(__tstate);
26520 if (PyErr_Occurred()) SWIG_fail;
26521 }
26522 {
26523 resultobj = SWIG_From_long((long)(result));
26524 }
26525 return resultobj;
26526 fail:
26527 return NULL;
26528 }
26529
26530
26531 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26532 PyObject *resultobj;
26533 long result;
26534 char *kwnames[] = {
26535 NULL
26536 };
26537
26538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26539 {
26540 PyThreadState* __tstate = wxPyBeginAllowThreads();
26541 result = (long)wxGetCurrentTime();
26542
26543 wxPyEndAllowThreads(__tstate);
26544 if (PyErr_Occurred()) SWIG_fail;
26545 }
26546 {
26547 resultobj = SWIG_From_long((long)(result));
26548 }
26549 return resultobj;
26550 fail:
26551 return NULL;
26552 }
26553
26554
26555 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26556 PyObject *resultobj;
26557 wxLongLong result;
26558 char *kwnames[] = {
26559 NULL
26560 };
26561
26562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26563 {
26564 PyThreadState* __tstate = wxPyBeginAllowThreads();
26565 result = wxGetLocalTimeMillis();
26566
26567 wxPyEndAllowThreads(__tstate);
26568 if (PyErr_Occurred()) SWIG_fail;
26569 }
26570 {
26571 PyObject *hi, *lo, *shifter, *shifted;
26572 hi = PyLong_FromLong( (&result)->GetHi() );
26573 lo = PyLong_FromLong( (&result)->GetLo() );
26574 shifter = PyLong_FromLong(32);
26575 shifted = PyNumber_Lshift(hi, shifter);
26576 resultobj = PyNumber_Or(shifted, lo);
26577 Py_DECREF(hi);
26578 Py_DECREF(lo);
26579 Py_DECREF(shifter);
26580 Py_DECREF(shifted);
26581 }
26582 return resultobj;
26583 fail:
26584 return NULL;
26585 }
26586
26587
26588 static int _wrap_DefaultDateTime_set(PyObject *) {
26589 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26590 return 1;
26591 }
26592
26593
26594 static PyObject *_wrap_DefaultDateTime_get(void) {
26595 PyObject *pyobj;
26596
26597 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26598 return pyobj;
26599 }
26600
26601
26602 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26603 PyObject *resultobj;
26604 wxDataFormatId arg1 ;
26605 wxDataFormat *result;
26606 PyObject * obj0 = 0 ;
26607 char *kwnames[] = {
26608 (char *) "type", NULL
26609 };
26610
26611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26612 {
26613 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26614 if (SWIG_arg_fail(1)) SWIG_fail;
26615 }
26616 {
26617 PyThreadState* __tstate = wxPyBeginAllowThreads();
26618 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26619
26620 wxPyEndAllowThreads(__tstate);
26621 if (PyErr_Occurred()) SWIG_fail;
26622 }
26623 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26624 return resultobj;
26625 fail:
26626 return NULL;
26627 }
26628
26629
26630 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26631 PyObject *resultobj;
26632 wxString *arg1 = 0 ;
26633 wxDataFormat *result;
26634 bool temp1 = false ;
26635 PyObject * obj0 = 0 ;
26636 char *kwnames[] = {
26637 (char *) "format", NULL
26638 };
26639
26640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26641 {
26642 arg1 = wxString_in_helper(obj0);
26643 if (arg1 == NULL) SWIG_fail;
26644 temp1 = true;
26645 }
26646 {
26647 PyThreadState* __tstate = wxPyBeginAllowThreads();
26648 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26649
26650 wxPyEndAllowThreads(__tstate);
26651 if (PyErr_Occurred()) SWIG_fail;
26652 }
26653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26654 {
26655 if (temp1)
26656 delete arg1;
26657 }
26658 return resultobj;
26659 fail:
26660 {
26661 if (temp1)
26662 delete arg1;
26663 }
26664 return NULL;
26665 }
26666
26667
26668 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26669 PyObject *resultobj;
26670 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26671 PyObject * obj0 = 0 ;
26672 char *kwnames[] = {
26673 (char *) "self", NULL
26674 };
26675
26676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26678 if (SWIG_arg_fail(1)) SWIG_fail;
26679 {
26680 PyThreadState* __tstate = wxPyBeginAllowThreads();
26681 delete arg1;
26682
26683 wxPyEndAllowThreads(__tstate);
26684 if (PyErr_Occurred()) SWIG_fail;
26685 }
26686 Py_INCREF(Py_None); resultobj = Py_None;
26687 return resultobj;
26688 fail:
26689 return NULL;
26690 }
26691
26692
26693 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26694 PyObject *resultobj;
26695 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26696 wxDataFormatId arg2 ;
26697 bool result;
26698 PyObject * obj0 = 0 ;
26699 PyObject * obj1 = 0 ;
26700
26701 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26703 if (SWIG_arg_fail(1)) SWIG_fail;
26704 {
26705 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26706 if (SWIG_arg_fail(2)) SWIG_fail;
26707 }
26708 {
26709 PyThreadState* __tstate = wxPyBeginAllowThreads();
26710 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26711
26712 wxPyEndAllowThreads(__tstate);
26713 if (PyErr_Occurred()) SWIG_fail;
26714 }
26715 {
26716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26717 }
26718 return resultobj;
26719 fail:
26720 return NULL;
26721 }
26722
26723
26724 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26725 PyObject *resultobj;
26726 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26727 wxDataFormatId arg2 ;
26728 bool result;
26729 PyObject * obj0 = 0 ;
26730 PyObject * obj1 = 0 ;
26731
26732 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26734 if (SWIG_arg_fail(1)) SWIG_fail;
26735 {
26736 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26737 if (SWIG_arg_fail(2)) SWIG_fail;
26738 }
26739 {
26740 PyThreadState* __tstate = wxPyBeginAllowThreads();
26741 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26742
26743 wxPyEndAllowThreads(__tstate);
26744 if (PyErr_Occurred()) SWIG_fail;
26745 }
26746 {
26747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26748 }
26749 return resultobj;
26750 fail:
26751 return NULL;
26752 }
26753
26754
26755 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26756 PyObject *resultobj;
26757 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26758 wxDataFormat *arg2 = 0 ;
26759 bool result;
26760 PyObject * obj0 = 0 ;
26761 PyObject * obj1 = 0 ;
26762
26763 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26765 if (SWIG_arg_fail(1)) SWIG_fail;
26766 {
26767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26768 if (SWIG_arg_fail(2)) SWIG_fail;
26769 if (arg2 == NULL) {
26770 SWIG_null_ref("wxDataFormat");
26771 }
26772 if (SWIG_arg_fail(2)) SWIG_fail;
26773 }
26774 {
26775 PyThreadState* __tstate = wxPyBeginAllowThreads();
26776 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26777
26778 wxPyEndAllowThreads(__tstate);
26779 if (PyErr_Occurred()) SWIG_fail;
26780 }
26781 {
26782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26783 }
26784 return resultobj;
26785 fail:
26786 return NULL;
26787 }
26788
26789
26790 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26791 int argc;
26792 PyObject *argv[3];
26793 int ii;
26794
26795 argc = PyObject_Length(args);
26796 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26797 argv[ii] = PyTuple_GetItem(args,ii);
26798 }
26799 if (argc == 2) {
26800 int _v;
26801 {
26802 void *ptr;
26803 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26804 _v = 0;
26805 PyErr_Clear();
26806 } else {
26807 _v = 1;
26808 }
26809 }
26810 if (_v) {
26811 {
26812 void *ptr = 0;
26813 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26814 _v = 0;
26815 PyErr_Clear();
26816 } else {
26817 _v = (ptr != 0);
26818 }
26819 }
26820 if (_v) {
26821 return _wrap_DataFormat___eq____SWIG_1(self,args);
26822 }
26823 }
26824 }
26825 if (argc == 2) {
26826 int _v;
26827 {
26828 void *ptr;
26829 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26830 _v = 0;
26831 PyErr_Clear();
26832 } else {
26833 _v = 1;
26834 }
26835 }
26836 if (_v) {
26837 _v = SWIG_Check_int(argv[1]);
26838 if (_v) {
26839 return _wrap_DataFormat___eq____SWIG_0(self,args);
26840 }
26841 }
26842 }
26843
26844 Py_INCREF(Py_NotImplemented);
26845 return Py_NotImplemented;
26846 }
26847
26848
26849 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26850 PyObject *resultobj;
26851 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26852 wxDataFormat *arg2 = 0 ;
26853 bool result;
26854 PyObject * obj0 = 0 ;
26855 PyObject * obj1 = 0 ;
26856
26857 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26859 if (SWIG_arg_fail(1)) SWIG_fail;
26860 {
26861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26862 if (SWIG_arg_fail(2)) SWIG_fail;
26863 if (arg2 == NULL) {
26864 SWIG_null_ref("wxDataFormat");
26865 }
26866 if (SWIG_arg_fail(2)) SWIG_fail;
26867 }
26868 {
26869 PyThreadState* __tstate = wxPyBeginAllowThreads();
26870 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26871
26872 wxPyEndAllowThreads(__tstate);
26873 if (PyErr_Occurred()) SWIG_fail;
26874 }
26875 {
26876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26877 }
26878 return resultobj;
26879 fail:
26880 return NULL;
26881 }
26882
26883
26884 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26885 int argc;
26886 PyObject *argv[3];
26887 int ii;
26888
26889 argc = PyObject_Length(args);
26890 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26891 argv[ii] = PyTuple_GetItem(args,ii);
26892 }
26893 if (argc == 2) {
26894 int _v;
26895 {
26896 void *ptr;
26897 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26898 _v = 0;
26899 PyErr_Clear();
26900 } else {
26901 _v = 1;
26902 }
26903 }
26904 if (_v) {
26905 {
26906 void *ptr = 0;
26907 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26908 _v = 0;
26909 PyErr_Clear();
26910 } else {
26911 _v = (ptr != 0);
26912 }
26913 }
26914 if (_v) {
26915 return _wrap_DataFormat___ne____SWIG_1(self,args);
26916 }
26917 }
26918 }
26919 if (argc == 2) {
26920 int _v;
26921 {
26922 void *ptr;
26923 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26924 _v = 0;
26925 PyErr_Clear();
26926 } else {
26927 _v = 1;
26928 }
26929 }
26930 if (_v) {
26931 _v = SWIG_Check_int(argv[1]);
26932 if (_v) {
26933 return _wrap_DataFormat___ne____SWIG_0(self,args);
26934 }
26935 }
26936 }
26937
26938 Py_INCREF(Py_NotImplemented);
26939 return Py_NotImplemented;
26940 }
26941
26942
26943 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26944 PyObject *resultobj;
26945 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26946 wxDataFormatId arg2 ;
26947 PyObject * obj0 = 0 ;
26948 PyObject * obj1 = 0 ;
26949 char *kwnames[] = {
26950 (char *) "self",(char *) "format", NULL
26951 };
26952
26953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26955 if (SWIG_arg_fail(1)) SWIG_fail;
26956 {
26957 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26958 if (SWIG_arg_fail(2)) SWIG_fail;
26959 }
26960 {
26961 PyThreadState* __tstate = wxPyBeginAllowThreads();
26962 (arg1)->SetType((wxDataFormatId )arg2);
26963
26964 wxPyEndAllowThreads(__tstate);
26965 if (PyErr_Occurred()) SWIG_fail;
26966 }
26967 Py_INCREF(Py_None); resultobj = Py_None;
26968 return resultobj;
26969 fail:
26970 return NULL;
26971 }
26972
26973
26974 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26975 PyObject *resultobj;
26976 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26977 wxDataFormatId result;
26978 PyObject * obj0 = 0 ;
26979 char *kwnames[] = {
26980 (char *) "self", NULL
26981 };
26982
26983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26985 if (SWIG_arg_fail(1)) SWIG_fail;
26986 {
26987 PyThreadState* __tstate = wxPyBeginAllowThreads();
26988 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26989
26990 wxPyEndAllowThreads(__tstate);
26991 if (PyErr_Occurred()) SWIG_fail;
26992 }
26993 resultobj = SWIG_From_int((result));
26994 return resultobj;
26995 fail:
26996 return NULL;
26997 }
26998
26999
27000 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
27001 PyObject *resultobj;
27002 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27003 wxString result;
27004 PyObject * obj0 = 0 ;
27005 char *kwnames[] = {
27006 (char *) "self", NULL
27007 };
27008
27009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
27010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27011 if (SWIG_arg_fail(1)) SWIG_fail;
27012 {
27013 PyThreadState* __tstate = wxPyBeginAllowThreads();
27014 result = ((wxDataFormat const *)arg1)->GetId();
27015
27016 wxPyEndAllowThreads(__tstate);
27017 if (PyErr_Occurred()) SWIG_fail;
27018 }
27019 {
27020 #if wxUSE_UNICODE
27021 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27022 #else
27023 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27024 #endif
27025 }
27026 return resultobj;
27027 fail:
27028 return NULL;
27029 }
27030
27031
27032 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
27033 PyObject *resultobj;
27034 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27035 wxString *arg2 = 0 ;
27036 bool temp2 = false ;
27037 PyObject * obj0 = 0 ;
27038 PyObject * obj1 = 0 ;
27039 char *kwnames[] = {
27040 (char *) "self",(char *) "format", NULL
27041 };
27042
27043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
27044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27045 if (SWIG_arg_fail(1)) SWIG_fail;
27046 {
27047 arg2 = wxString_in_helper(obj1);
27048 if (arg2 == NULL) SWIG_fail;
27049 temp2 = true;
27050 }
27051 {
27052 PyThreadState* __tstate = wxPyBeginAllowThreads();
27053 (arg1)->SetId((wxString const &)*arg2);
27054
27055 wxPyEndAllowThreads(__tstate);
27056 if (PyErr_Occurred()) SWIG_fail;
27057 }
27058 Py_INCREF(Py_None); resultobj = Py_None;
27059 {
27060 if (temp2)
27061 delete arg2;
27062 }
27063 return resultobj;
27064 fail:
27065 {
27066 if (temp2)
27067 delete arg2;
27068 }
27069 return NULL;
27070 }
27071
27072
27073 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27074 PyObject *obj;
27075 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27076 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27077 Py_INCREF(obj);
27078 return Py_BuildValue((char *)"");
27079 }
27080 static int _wrap_FormatInvalid_set(PyObject *) {
27081 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27082 return 1;
27083 }
27084
27085
27086 static PyObject *_wrap_FormatInvalid_get(void) {
27087 PyObject *pyobj;
27088
27089 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27090 return pyobj;
27091 }
27092
27093
27094 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27095 PyObject *resultobj;
27096 wxDataObject *arg1 = (wxDataObject *) 0 ;
27097 PyObject * obj0 = 0 ;
27098 char *kwnames[] = {
27099 (char *) "self", NULL
27100 };
27101
27102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27104 if (SWIG_arg_fail(1)) SWIG_fail;
27105 {
27106 PyThreadState* __tstate = wxPyBeginAllowThreads();
27107 delete arg1;
27108
27109 wxPyEndAllowThreads(__tstate);
27110 if (PyErr_Occurred()) SWIG_fail;
27111 }
27112 Py_INCREF(Py_None); resultobj = Py_None;
27113 return resultobj;
27114 fail:
27115 return NULL;
27116 }
27117
27118
27119 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27120 PyObject *resultobj;
27121 wxDataObject *arg1 = (wxDataObject *) 0 ;
27122 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27123 SwigValueWrapper<wxDataFormat > result;
27124 PyObject * obj0 = 0 ;
27125 PyObject * obj1 = 0 ;
27126 char *kwnames[] = {
27127 (char *) "self",(char *) "dir", NULL
27128 };
27129
27130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27132 if (SWIG_arg_fail(1)) SWIG_fail;
27133 if (obj1) {
27134 {
27135 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27136 if (SWIG_arg_fail(2)) SWIG_fail;
27137 }
27138 }
27139 {
27140 PyThreadState* __tstate = wxPyBeginAllowThreads();
27141 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27142
27143 wxPyEndAllowThreads(__tstate);
27144 if (PyErr_Occurred()) SWIG_fail;
27145 }
27146 {
27147 wxDataFormat * resultptr;
27148 resultptr = new wxDataFormat((wxDataFormat &)(result));
27149 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27150 }
27151 return resultobj;
27152 fail:
27153 return NULL;
27154 }
27155
27156
27157 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27158 PyObject *resultobj;
27159 wxDataObject *arg1 = (wxDataObject *) 0 ;
27160 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27161 size_t result;
27162 PyObject * obj0 = 0 ;
27163 PyObject * obj1 = 0 ;
27164 char *kwnames[] = {
27165 (char *) "self",(char *) "dir", NULL
27166 };
27167
27168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27170 if (SWIG_arg_fail(1)) SWIG_fail;
27171 if (obj1) {
27172 {
27173 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27174 if (SWIG_arg_fail(2)) SWIG_fail;
27175 }
27176 }
27177 {
27178 PyThreadState* __tstate = wxPyBeginAllowThreads();
27179 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27180
27181 wxPyEndAllowThreads(__tstate);
27182 if (PyErr_Occurred()) SWIG_fail;
27183 }
27184 {
27185 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27186 }
27187 return resultobj;
27188 fail:
27189 return NULL;
27190 }
27191
27192
27193 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27194 PyObject *resultobj;
27195 wxDataObject *arg1 = (wxDataObject *) 0 ;
27196 wxDataFormat *arg2 = 0 ;
27197 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27198 bool result;
27199 PyObject * obj0 = 0 ;
27200 PyObject * obj1 = 0 ;
27201 PyObject * obj2 = 0 ;
27202 char *kwnames[] = {
27203 (char *) "self",(char *) "format",(char *) "dir", NULL
27204 };
27205
27206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27208 if (SWIG_arg_fail(1)) SWIG_fail;
27209 {
27210 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27211 if (SWIG_arg_fail(2)) SWIG_fail;
27212 if (arg2 == NULL) {
27213 SWIG_null_ref("wxDataFormat");
27214 }
27215 if (SWIG_arg_fail(2)) SWIG_fail;
27216 }
27217 if (obj2) {
27218 {
27219 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27220 if (SWIG_arg_fail(3)) SWIG_fail;
27221 }
27222 }
27223 {
27224 PyThreadState* __tstate = wxPyBeginAllowThreads();
27225 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27226
27227 wxPyEndAllowThreads(__tstate);
27228 if (PyErr_Occurred()) SWIG_fail;
27229 }
27230 {
27231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27232 }
27233 return resultobj;
27234 fail:
27235 return NULL;
27236 }
27237
27238
27239 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27240 PyObject *resultobj;
27241 wxDataObject *arg1 = (wxDataObject *) 0 ;
27242 wxDataFormat *arg2 = 0 ;
27243 size_t result;
27244 PyObject * obj0 = 0 ;
27245 PyObject * obj1 = 0 ;
27246 char *kwnames[] = {
27247 (char *) "self",(char *) "format", NULL
27248 };
27249
27250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27252 if (SWIG_arg_fail(1)) SWIG_fail;
27253 {
27254 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27255 if (SWIG_arg_fail(2)) SWIG_fail;
27256 if (arg2 == NULL) {
27257 SWIG_null_ref("wxDataFormat");
27258 }
27259 if (SWIG_arg_fail(2)) SWIG_fail;
27260 }
27261 {
27262 PyThreadState* __tstate = wxPyBeginAllowThreads();
27263 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27264
27265 wxPyEndAllowThreads(__tstate);
27266 if (PyErr_Occurred()) SWIG_fail;
27267 }
27268 {
27269 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27270 }
27271 return resultobj;
27272 fail:
27273 return NULL;
27274 }
27275
27276
27277 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27278 PyObject *resultobj;
27279 wxDataObject *arg1 = (wxDataObject *) 0 ;
27280 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27281 PyObject *result;
27282 PyObject * obj0 = 0 ;
27283 PyObject * obj1 = 0 ;
27284 char *kwnames[] = {
27285 (char *) "self",(char *) "dir", NULL
27286 };
27287
27288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27290 if (SWIG_arg_fail(1)) SWIG_fail;
27291 if (obj1) {
27292 {
27293 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27294 if (SWIG_arg_fail(2)) SWIG_fail;
27295 }
27296 }
27297 {
27298 PyThreadState* __tstate = wxPyBeginAllowThreads();
27299 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27300
27301 wxPyEndAllowThreads(__tstate);
27302 if (PyErr_Occurred()) SWIG_fail;
27303 }
27304 resultobj = result;
27305 return resultobj;
27306 fail:
27307 return NULL;
27308 }
27309
27310
27311 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27312 PyObject *resultobj;
27313 wxDataObject *arg1 = (wxDataObject *) 0 ;
27314 wxDataFormat *arg2 = 0 ;
27315 PyObject *result;
27316 PyObject * obj0 = 0 ;
27317 PyObject * obj1 = 0 ;
27318 char *kwnames[] = {
27319 (char *) "self",(char *) "format", NULL
27320 };
27321
27322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27324 if (SWIG_arg_fail(1)) SWIG_fail;
27325 {
27326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27327 if (SWIG_arg_fail(2)) SWIG_fail;
27328 if (arg2 == NULL) {
27329 SWIG_null_ref("wxDataFormat");
27330 }
27331 if (SWIG_arg_fail(2)) SWIG_fail;
27332 }
27333 {
27334 PyThreadState* __tstate = wxPyBeginAllowThreads();
27335 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27336
27337 wxPyEndAllowThreads(__tstate);
27338 if (PyErr_Occurred()) SWIG_fail;
27339 }
27340 resultobj = result;
27341 return resultobj;
27342 fail:
27343 return NULL;
27344 }
27345
27346
27347 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27348 PyObject *resultobj;
27349 wxDataObject *arg1 = (wxDataObject *) 0 ;
27350 wxDataFormat *arg2 = 0 ;
27351 PyObject *arg3 = (PyObject *) 0 ;
27352 bool result;
27353 PyObject * obj0 = 0 ;
27354 PyObject * obj1 = 0 ;
27355 PyObject * obj2 = 0 ;
27356 char *kwnames[] = {
27357 (char *) "self",(char *) "format",(char *) "data", NULL
27358 };
27359
27360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27362 if (SWIG_arg_fail(1)) SWIG_fail;
27363 {
27364 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27365 if (SWIG_arg_fail(2)) SWIG_fail;
27366 if (arg2 == NULL) {
27367 SWIG_null_ref("wxDataFormat");
27368 }
27369 if (SWIG_arg_fail(2)) SWIG_fail;
27370 }
27371 arg3 = obj2;
27372 {
27373 PyThreadState* __tstate = wxPyBeginAllowThreads();
27374 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27375
27376 wxPyEndAllowThreads(__tstate);
27377 if (PyErr_Occurred()) SWIG_fail;
27378 }
27379 {
27380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27381 }
27382 return resultobj;
27383 fail:
27384 return NULL;
27385 }
27386
27387
27388 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27389 PyObject *obj;
27390 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27391 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27392 Py_INCREF(obj);
27393 return Py_BuildValue((char *)"");
27394 }
27395 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27396 PyObject *resultobj;
27397 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27398 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27399 wxDataObjectSimple *result;
27400 PyObject * obj0 = 0 ;
27401 char *kwnames[] = {
27402 (char *) "format", NULL
27403 };
27404
27405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27406 if (obj0) {
27407 {
27408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27409 if (SWIG_arg_fail(1)) SWIG_fail;
27410 if (arg1 == NULL) {
27411 SWIG_null_ref("wxDataFormat");
27412 }
27413 if (SWIG_arg_fail(1)) SWIG_fail;
27414 }
27415 }
27416 {
27417 PyThreadState* __tstate = wxPyBeginAllowThreads();
27418 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27419
27420 wxPyEndAllowThreads(__tstate);
27421 if (PyErr_Occurred()) SWIG_fail;
27422 }
27423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27431 PyObject *resultobj;
27432 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27433 wxDataFormat *result;
27434 PyObject * obj0 = 0 ;
27435 char *kwnames[] = {
27436 (char *) "self", NULL
27437 };
27438
27439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27441 if (SWIG_arg_fail(1)) SWIG_fail;
27442 {
27443 PyThreadState* __tstate = wxPyBeginAllowThreads();
27444 {
27445 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27446 result = (wxDataFormat *) &_result_ref;
27447 }
27448
27449 wxPyEndAllowThreads(__tstate);
27450 if (PyErr_Occurred()) SWIG_fail;
27451 }
27452 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27453 return resultobj;
27454 fail:
27455 return NULL;
27456 }
27457
27458
27459 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27460 PyObject *resultobj;
27461 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27462 wxDataFormat *arg2 = 0 ;
27463 PyObject * obj0 = 0 ;
27464 PyObject * obj1 = 0 ;
27465 char *kwnames[] = {
27466 (char *) "self",(char *) "format", NULL
27467 };
27468
27469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27471 if (SWIG_arg_fail(1)) SWIG_fail;
27472 {
27473 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27474 if (SWIG_arg_fail(2)) SWIG_fail;
27475 if (arg2 == NULL) {
27476 SWIG_null_ref("wxDataFormat");
27477 }
27478 if (SWIG_arg_fail(2)) SWIG_fail;
27479 }
27480 {
27481 PyThreadState* __tstate = wxPyBeginAllowThreads();
27482 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27483
27484 wxPyEndAllowThreads(__tstate);
27485 if (PyErr_Occurred()) SWIG_fail;
27486 }
27487 Py_INCREF(Py_None); resultobj = Py_None;
27488 return resultobj;
27489 fail:
27490 return NULL;
27491 }
27492
27493
27494 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27495 PyObject *resultobj;
27496 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27497 size_t result;
27498 PyObject * obj0 = 0 ;
27499 char *kwnames[] = {
27500 (char *) "self", NULL
27501 };
27502
27503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27505 if (SWIG_arg_fail(1)) SWIG_fail;
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27509
27510 wxPyEndAllowThreads(__tstate);
27511 if (PyErr_Occurred()) SWIG_fail;
27512 }
27513 {
27514 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27515 }
27516 return resultobj;
27517 fail:
27518 return NULL;
27519 }
27520
27521
27522 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27523 PyObject *resultobj;
27524 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27525 PyObject *result;
27526 PyObject * obj0 = 0 ;
27527 char *kwnames[] = {
27528 (char *) "self", NULL
27529 };
27530
27531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27533 if (SWIG_arg_fail(1)) SWIG_fail;
27534 {
27535 PyThreadState* __tstate = wxPyBeginAllowThreads();
27536 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27537
27538 wxPyEndAllowThreads(__tstate);
27539 if (PyErr_Occurred()) SWIG_fail;
27540 }
27541 resultobj = result;
27542 return resultobj;
27543 fail:
27544 return NULL;
27545 }
27546
27547
27548 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27549 PyObject *resultobj;
27550 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27551 PyObject *arg2 = (PyObject *) 0 ;
27552 bool result;
27553 PyObject * obj0 = 0 ;
27554 PyObject * obj1 = 0 ;
27555 char *kwnames[] = {
27556 (char *) "self",(char *) "data", NULL
27557 };
27558
27559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27561 if (SWIG_arg_fail(1)) SWIG_fail;
27562 arg2 = obj1;
27563 {
27564 PyThreadState* __tstate = wxPyBeginAllowThreads();
27565 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27566
27567 wxPyEndAllowThreads(__tstate);
27568 if (PyErr_Occurred()) SWIG_fail;
27569 }
27570 {
27571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27572 }
27573 return resultobj;
27574 fail:
27575 return NULL;
27576 }
27577
27578
27579 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27580 PyObject *obj;
27581 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27582 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27583 Py_INCREF(obj);
27584 return Py_BuildValue((char *)"");
27585 }
27586 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27587 PyObject *resultobj;
27588 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27589 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27590 wxPyDataObjectSimple *result;
27591 PyObject * obj0 = 0 ;
27592 char *kwnames[] = {
27593 (char *) "format", NULL
27594 };
27595
27596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27597 if (obj0) {
27598 {
27599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27600 if (SWIG_arg_fail(1)) SWIG_fail;
27601 if (arg1 == NULL) {
27602 SWIG_null_ref("wxDataFormat");
27603 }
27604 if (SWIG_arg_fail(1)) SWIG_fail;
27605 }
27606 }
27607 {
27608 PyThreadState* __tstate = wxPyBeginAllowThreads();
27609 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27610
27611 wxPyEndAllowThreads(__tstate);
27612 if (PyErr_Occurred()) SWIG_fail;
27613 }
27614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27615 return resultobj;
27616 fail:
27617 return NULL;
27618 }
27619
27620
27621 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27622 PyObject *resultobj;
27623 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27624 PyObject *arg2 = (PyObject *) 0 ;
27625 PyObject *arg3 = (PyObject *) 0 ;
27626 PyObject * obj0 = 0 ;
27627 PyObject * obj1 = 0 ;
27628 PyObject * obj2 = 0 ;
27629 char *kwnames[] = {
27630 (char *) "self",(char *) "self",(char *) "_class", NULL
27631 };
27632
27633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27635 if (SWIG_arg_fail(1)) SWIG_fail;
27636 arg2 = obj1;
27637 arg3 = obj2;
27638 {
27639 PyThreadState* __tstate = wxPyBeginAllowThreads();
27640 (arg1)->_setCallbackInfo(arg2,arg3);
27641
27642 wxPyEndAllowThreads(__tstate);
27643 if (PyErr_Occurred()) SWIG_fail;
27644 }
27645 Py_INCREF(Py_None); resultobj = Py_None;
27646 return resultobj;
27647 fail:
27648 return NULL;
27649 }
27650
27651
27652 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27653 PyObject *obj;
27654 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27655 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27656 Py_INCREF(obj);
27657 return Py_BuildValue((char *)"");
27658 }
27659 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27660 PyObject *resultobj;
27661 wxDataObjectComposite *result;
27662 char *kwnames[] = {
27663 NULL
27664 };
27665
27666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27667 {
27668 PyThreadState* __tstate = wxPyBeginAllowThreads();
27669 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27670
27671 wxPyEndAllowThreads(__tstate);
27672 if (PyErr_Occurred()) SWIG_fail;
27673 }
27674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27675 return resultobj;
27676 fail:
27677 return NULL;
27678 }
27679
27680
27681 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27682 PyObject *resultobj;
27683 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27684 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27685 bool arg3 = (bool) false ;
27686 PyObject * obj0 = 0 ;
27687 PyObject * obj1 = 0 ;
27688 PyObject * obj2 = 0 ;
27689 char *kwnames[] = {
27690 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27691 };
27692
27693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27695 if (SWIG_arg_fail(1)) SWIG_fail;
27696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27697 if (SWIG_arg_fail(2)) SWIG_fail;
27698 if (obj2) {
27699 {
27700 arg3 = (bool)(SWIG_As_bool(obj2));
27701 if (SWIG_arg_fail(3)) SWIG_fail;
27702 }
27703 }
27704 {
27705 PyThreadState* __tstate = wxPyBeginAllowThreads();
27706 (arg1)->Add(arg2,arg3);
27707
27708 wxPyEndAllowThreads(__tstate);
27709 if (PyErr_Occurred()) SWIG_fail;
27710 }
27711 Py_INCREF(Py_None); resultobj = Py_None;
27712 return resultobj;
27713 fail:
27714 return NULL;
27715 }
27716
27717
27718 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27719 PyObject *obj;
27720 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27721 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27722 Py_INCREF(obj);
27723 return Py_BuildValue((char *)"");
27724 }
27725 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27726 PyObject *resultobj;
27727 wxString const &arg1_defvalue = wxPyEmptyString ;
27728 wxString *arg1 = (wxString *) &arg1_defvalue ;
27729 wxTextDataObject *result;
27730 bool temp1 = false ;
27731 PyObject * obj0 = 0 ;
27732 char *kwnames[] = {
27733 (char *) "text", NULL
27734 };
27735
27736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27737 if (obj0) {
27738 {
27739 arg1 = wxString_in_helper(obj0);
27740 if (arg1 == NULL) SWIG_fail;
27741 temp1 = true;
27742 }
27743 }
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27747
27748 wxPyEndAllowThreads(__tstate);
27749 if (PyErr_Occurred()) SWIG_fail;
27750 }
27751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27752 {
27753 if (temp1)
27754 delete arg1;
27755 }
27756 return resultobj;
27757 fail:
27758 {
27759 if (temp1)
27760 delete arg1;
27761 }
27762 return NULL;
27763 }
27764
27765
27766 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27767 PyObject *resultobj;
27768 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27769 size_t result;
27770 PyObject * obj0 = 0 ;
27771 char *kwnames[] = {
27772 (char *) "self", NULL
27773 };
27774
27775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27777 if (SWIG_arg_fail(1)) SWIG_fail;
27778 {
27779 PyThreadState* __tstate = wxPyBeginAllowThreads();
27780 result = (size_t)(arg1)->GetTextLength();
27781
27782 wxPyEndAllowThreads(__tstate);
27783 if (PyErr_Occurred()) SWIG_fail;
27784 }
27785 {
27786 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27787 }
27788 return resultobj;
27789 fail:
27790 return NULL;
27791 }
27792
27793
27794 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27795 PyObject *resultobj;
27796 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27797 wxString result;
27798 PyObject * obj0 = 0 ;
27799 char *kwnames[] = {
27800 (char *) "self", NULL
27801 };
27802
27803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27805 if (SWIG_arg_fail(1)) SWIG_fail;
27806 {
27807 PyThreadState* __tstate = wxPyBeginAllowThreads();
27808 result = (arg1)->GetText();
27809
27810 wxPyEndAllowThreads(__tstate);
27811 if (PyErr_Occurred()) SWIG_fail;
27812 }
27813 {
27814 #if wxUSE_UNICODE
27815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27816 #else
27817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27818 #endif
27819 }
27820 return resultobj;
27821 fail:
27822 return NULL;
27823 }
27824
27825
27826 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27827 PyObject *resultobj;
27828 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27829 wxString *arg2 = 0 ;
27830 bool temp2 = false ;
27831 PyObject * obj0 = 0 ;
27832 PyObject * obj1 = 0 ;
27833 char *kwnames[] = {
27834 (char *) "self",(char *) "text", NULL
27835 };
27836
27837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27839 if (SWIG_arg_fail(1)) SWIG_fail;
27840 {
27841 arg2 = wxString_in_helper(obj1);
27842 if (arg2 == NULL) SWIG_fail;
27843 temp2 = true;
27844 }
27845 {
27846 PyThreadState* __tstate = wxPyBeginAllowThreads();
27847 (arg1)->SetText((wxString const &)*arg2);
27848
27849 wxPyEndAllowThreads(__tstate);
27850 if (PyErr_Occurred()) SWIG_fail;
27851 }
27852 Py_INCREF(Py_None); resultobj = Py_None;
27853 {
27854 if (temp2)
27855 delete arg2;
27856 }
27857 return resultobj;
27858 fail:
27859 {
27860 if (temp2)
27861 delete arg2;
27862 }
27863 return NULL;
27864 }
27865
27866
27867 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27868 PyObject *obj;
27869 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27870 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27871 Py_INCREF(obj);
27872 return Py_BuildValue((char *)"");
27873 }
27874 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27875 PyObject *resultobj;
27876 wxString const &arg1_defvalue = wxPyEmptyString ;
27877 wxString *arg1 = (wxString *) &arg1_defvalue ;
27878 wxPyTextDataObject *result;
27879 bool temp1 = false ;
27880 PyObject * obj0 = 0 ;
27881 char *kwnames[] = {
27882 (char *) "text", NULL
27883 };
27884
27885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27886 if (obj0) {
27887 {
27888 arg1 = wxString_in_helper(obj0);
27889 if (arg1 == NULL) SWIG_fail;
27890 temp1 = true;
27891 }
27892 }
27893 {
27894 PyThreadState* __tstate = wxPyBeginAllowThreads();
27895 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27896
27897 wxPyEndAllowThreads(__tstate);
27898 if (PyErr_Occurred()) SWIG_fail;
27899 }
27900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27901 {
27902 if (temp1)
27903 delete arg1;
27904 }
27905 return resultobj;
27906 fail:
27907 {
27908 if (temp1)
27909 delete arg1;
27910 }
27911 return NULL;
27912 }
27913
27914
27915 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27916 PyObject *resultobj;
27917 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27918 PyObject *arg2 = (PyObject *) 0 ;
27919 PyObject *arg3 = (PyObject *) 0 ;
27920 PyObject * obj0 = 0 ;
27921 PyObject * obj1 = 0 ;
27922 PyObject * obj2 = 0 ;
27923 char *kwnames[] = {
27924 (char *) "self",(char *) "self",(char *) "_class", NULL
27925 };
27926
27927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27929 if (SWIG_arg_fail(1)) SWIG_fail;
27930 arg2 = obj1;
27931 arg3 = obj2;
27932 {
27933 PyThreadState* __tstate = wxPyBeginAllowThreads();
27934 (arg1)->_setCallbackInfo(arg2,arg3);
27935
27936 wxPyEndAllowThreads(__tstate);
27937 if (PyErr_Occurred()) SWIG_fail;
27938 }
27939 Py_INCREF(Py_None); resultobj = Py_None;
27940 return resultobj;
27941 fail:
27942 return NULL;
27943 }
27944
27945
27946 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27947 PyObject *obj;
27948 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27949 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27950 Py_INCREF(obj);
27951 return Py_BuildValue((char *)"");
27952 }
27953 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27954 PyObject *resultobj;
27955 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27956 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27957 wxBitmapDataObject *result;
27958 PyObject * obj0 = 0 ;
27959 char *kwnames[] = {
27960 (char *) "bitmap", NULL
27961 };
27962
27963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27964 if (obj0) {
27965 {
27966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27967 if (SWIG_arg_fail(1)) SWIG_fail;
27968 if (arg1 == NULL) {
27969 SWIG_null_ref("wxBitmap");
27970 }
27971 if (SWIG_arg_fail(1)) SWIG_fail;
27972 }
27973 }
27974 {
27975 PyThreadState* __tstate = wxPyBeginAllowThreads();
27976 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27977
27978 wxPyEndAllowThreads(__tstate);
27979 if (PyErr_Occurred()) SWIG_fail;
27980 }
27981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27982 return resultobj;
27983 fail:
27984 return NULL;
27985 }
27986
27987
27988 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27989 PyObject *resultobj;
27990 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27991 wxBitmap result;
27992 PyObject * obj0 = 0 ;
27993 char *kwnames[] = {
27994 (char *) "self", NULL
27995 };
27996
27997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27999 if (SWIG_arg_fail(1)) SWIG_fail;
28000 {
28001 PyThreadState* __tstate = wxPyBeginAllowThreads();
28002 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
28003
28004 wxPyEndAllowThreads(__tstate);
28005 if (PyErr_Occurred()) SWIG_fail;
28006 }
28007 {
28008 wxBitmap * resultptr;
28009 resultptr = new wxBitmap((wxBitmap &)(result));
28010 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
28011 }
28012 return resultobj;
28013 fail:
28014 return NULL;
28015 }
28016
28017
28018 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
28019 PyObject *resultobj;
28020 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
28021 wxBitmap *arg2 = 0 ;
28022 PyObject * obj0 = 0 ;
28023 PyObject * obj1 = 0 ;
28024 char *kwnames[] = {
28025 (char *) "self",(char *) "bitmap", NULL
28026 };
28027
28028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
28029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28030 if (SWIG_arg_fail(1)) SWIG_fail;
28031 {
28032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28033 if (SWIG_arg_fail(2)) SWIG_fail;
28034 if (arg2 == NULL) {
28035 SWIG_null_ref("wxBitmap");
28036 }
28037 if (SWIG_arg_fail(2)) SWIG_fail;
28038 }
28039 {
28040 PyThreadState* __tstate = wxPyBeginAllowThreads();
28041 (arg1)->SetBitmap((wxBitmap const &)*arg2);
28042
28043 wxPyEndAllowThreads(__tstate);
28044 if (PyErr_Occurred()) SWIG_fail;
28045 }
28046 Py_INCREF(Py_None); resultobj = Py_None;
28047 return resultobj;
28048 fail:
28049 return NULL;
28050 }
28051
28052
28053 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
28054 PyObject *obj;
28055 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28056 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
28057 Py_INCREF(obj);
28058 return Py_BuildValue((char *)"");
28059 }
28060 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28061 PyObject *resultobj;
28062 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28063 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28064 wxPyBitmapDataObject *result;
28065 PyObject * obj0 = 0 ;
28066 char *kwnames[] = {
28067 (char *) "bitmap", NULL
28068 };
28069
28070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28071 if (obj0) {
28072 {
28073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28074 if (SWIG_arg_fail(1)) SWIG_fail;
28075 if (arg1 == NULL) {
28076 SWIG_null_ref("wxBitmap");
28077 }
28078 if (SWIG_arg_fail(1)) SWIG_fail;
28079 }
28080 }
28081 {
28082 PyThreadState* __tstate = wxPyBeginAllowThreads();
28083 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28084
28085 wxPyEndAllowThreads(__tstate);
28086 if (PyErr_Occurred()) SWIG_fail;
28087 }
28088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28089 return resultobj;
28090 fail:
28091 return NULL;
28092 }
28093
28094
28095 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28096 PyObject *resultobj;
28097 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28098 PyObject *arg2 = (PyObject *) 0 ;
28099 PyObject *arg3 = (PyObject *) 0 ;
28100 PyObject * obj0 = 0 ;
28101 PyObject * obj1 = 0 ;
28102 PyObject * obj2 = 0 ;
28103 char *kwnames[] = {
28104 (char *) "self",(char *) "self",(char *) "_class", NULL
28105 };
28106
28107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28109 if (SWIG_arg_fail(1)) SWIG_fail;
28110 arg2 = obj1;
28111 arg3 = obj2;
28112 {
28113 PyThreadState* __tstate = wxPyBeginAllowThreads();
28114 (arg1)->_setCallbackInfo(arg2,arg3);
28115
28116 wxPyEndAllowThreads(__tstate);
28117 if (PyErr_Occurred()) SWIG_fail;
28118 }
28119 Py_INCREF(Py_None); resultobj = Py_None;
28120 return resultobj;
28121 fail:
28122 return NULL;
28123 }
28124
28125
28126 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28127 PyObject *obj;
28128 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28129 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28130 Py_INCREF(obj);
28131 return Py_BuildValue((char *)"");
28132 }
28133 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28134 PyObject *resultobj;
28135 wxFileDataObject *result;
28136 char *kwnames[] = {
28137 NULL
28138 };
28139
28140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28141 {
28142 PyThreadState* __tstate = wxPyBeginAllowThreads();
28143 result = (wxFileDataObject *)new wxFileDataObject();
28144
28145 wxPyEndAllowThreads(__tstate);
28146 if (PyErr_Occurred()) SWIG_fail;
28147 }
28148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28149 return resultobj;
28150 fail:
28151 return NULL;
28152 }
28153
28154
28155 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28156 PyObject *resultobj;
28157 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28158 wxArrayString *result;
28159 PyObject * obj0 = 0 ;
28160 char *kwnames[] = {
28161 (char *) "self", NULL
28162 };
28163
28164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28166 if (SWIG_arg_fail(1)) SWIG_fail;
28167 {
28168 PyThreadState* __tstate = wxPyBeginAllowThreads();
28169 {
28170 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28171 result = (wxArrayString *) &_result_ref;
28172 }
28173
28174 wxPyEndAllowThreads(__tstate);
28175 if (PyErr_Occurred()) SWIG_fail;
28176 }
28177 {
28178 resultobj = wxArrayString2PyList_helper(*result);
28179 }
28180 return resultobj;
28181 fail:
28182 return NULL;
28183 }
28184
28185
28186 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28187 PyObject *resultobj;
28188 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28189 wxString *arg2 = 0 ;
28190 bool temp2 = false ;
28191 PyObject * obj0 = 0 ;
28192 PyObject * obj1 = 0 ;
28193 char *kwnames[] = {
28194 (char *) "self",(char *) "filename", NULL
28195 };
28196
28197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28199 if (SWIG_arg_fail(1)) SWIG_fail;
28200 {
28201 arg2 = wxString_in_helper(obj1);
28202 if (arg2 == NULL) SWIG_fail;
28203 temp2 = true;
28204 }
28205 {
28206 PyThreadState* __tstate = wxPyBeginAllowThreads();
28207 (arg1)->AddFile((wxString const &)*arg2);
28208
28209 wxPyEndAllowThreads(__tstate);
28210 if (PyErr_Occurred()) SWIG_fail;
28211 }
28212 Py_INCREF(Py_None); resultobj = Py_None;
28213 {
28214 if (temp2)
28215 delete arg2;
28216 }
28217 return resultobj;
28218 fail:
28219 {
28220 if (temp2)
28221 delete arg2;
28222 }
28223 return NULL;
28224 }
28225
28226
28227 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28228 PyObject *obj;
28229 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28230 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28231 Py_INCREF(obj);
28232 return Py_BuildValue((char *)"");
28233 }
28234 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28235 PyObject *resultobj;
28236 wxDataFormat *arg1 = 0 ;
28237 wxCustomDataObject *result;
28238 PyObject * obj0 = 0 ;
28239
28240 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28241 {
28242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28243 if (SWIG_arg_fail(1)) SWIG_fail;
28244 if (arg1 == NULL) {
28245 SWIG_null_ref("wxDataFormat");
28246 }
28247 if (SWIG_arg_fail(1)) SWIG_fail;
28248 }
28249 {
28250 PyThreadState* __tstate = wxPyBeginAllowThreads();
28251 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28252
28253 wxPyEndAllowThreads(__tstate);
28254 if (PyErr_Occurred()) SWIG_fail;
28255 }
28256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28257 return resultobj;
28258 fail:
28259 return NULL;
28260 }
28261
28262
28263 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28264 PyObject *resultobj;
28265 wxString *arg1 = 0 ;
28266 wxCustomDataObject *result;
28267 bool temp1 = false ;
28268 PyObject * obj0 = 0 ;
28269
28270 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28271 {
28272 arg1 = wxString_in_helper(obj0);
28273 if (arg1 == NULL) SWIG_fail;
28274 temp1 = true;
28275 }
28276 {
28277 PyThreadState* __tstate = wxPyBeginAllowThreads();
28278 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28279
28280 wxPyEndAllowThreads(__tstate);
28281 if (PyErr_Occurred()) SWIG_fail;
28282 }
28283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28284 {
28285 if (temp1)
28286 delete arg1;
28287 }
28288 return resultobj;
28289 fail:
28290 {
28291 if (temp1)
28292 delete arg1;
28293 }
28294 return NULL;
28295 }
28296
28297
28298 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28299 PyObject *resultobj;
28300 wxCustomDataObject *result;
28301
28302 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28303 {
28304 PyThreadState* __tstate = wxPyBeginAllowThreads();
28305 result = (wxCustomDataObject *)new wxCustomDataObject();
28306
28307 wxPyEndAllowThreads(__tstate);
28308 if (PyErr_Occurred()) SWIG_fail;
28309 }
28310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28311 return resultobj;
28312 fail:
28313 return NULL;
28314 }
28315
28316
28317 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28318 int argc;
28319 PyObject *argv[2];
28320 int ii;
28321
28322 argc = PyObject_Length(args);
28323 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28324 argv[ii] = PyTuple_GetItem(args,ii);
28325 }
28326 if (argc == 0) {
28327 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28328 }
28329 if (argc == 1) {
28330 int _v;
28331 {
28332 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28333 }
28334 if (_v) {
28335 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28336 }
28337 }
28338 if (argc == 1) {
28339 int _v;
28340 {
28341 void *ptr = 0;
28342 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28343 _v = 0;
28344 PyErr_Clear();
28345 } else {
28346 _v = (ptr != 0);
28347 }
28348 }
28349 if (_v) {
28350 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28351 }
28352 }
28353
28354 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28355 return NULL;
28356 }
28357
28358
28359 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28360 PyObject *resultobj;
28361 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28362 PyObject *arg2 = (PyObject *) 0 ;
28363 bool result;
28364 PyObject * obj0 = 0 ;
28365 PyObject * obj1 = 0 ;
28366 char *kwnames[] = {
28367 (char *) "self",(char *) "data", NULL
28368 };
28369
28370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28372 if (SWIG_arg_fail(1)) SWIG_fail;
28373 arg2 = obj1;
28374 {
28375 PyThreadState* __tstate = wxPyBeginAllowThreads();
28376 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28377
28378 wxPyEndAllowThreads(__tstate);
28379 if (PyErr_Occurred()) SWIG_fail;
28380 }
28381 {
28382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28383 }
28384 return resultobj;
28385 fail:
28386 return NULL;
28387 }
28388
28389
28390 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28391 PyObject *resultobj;
28392 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28393 size_t result;
28394 PyObject * obj0 = 0 ;
28395 char *kwnames[] = {
28396 (char *) "self", NULL
28397 };
28398
28399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28401 if (SWIG_arg_fail(1)) SWIG_fail;
28402 {
28403 PyThreadState* __tstate = wxPyBeginAllowThreads();
28404 result = (size_t)(arg1)->GetSize();
28405
28406 wxPyEndAllowThreads(__tstate);
28407 if (PyErr_Occurred()) SWIG_fail;
28408 }
28409 {
28410 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28411 }
28412 return resultobj;
28413 fail:
28414 return NULL;
28415 }
28416
28417
28418 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28419 PyObject *resultobj;
28420 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28421 PyObject *result;
28422 PyObject * obj0 = 0 ;
28423 char *kwnames[] = {
28424 (char *) "self", NULL
28425 };
28426
28427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28429 if (SWIG_arg_fail(1)) SWIG_fail;
28430 {
28431 PyThreadState* __tstate = wxPyBeginAllowThreads();
28432 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28433
28434 wxPyEndAllowThreads(__tstate);
28435 if (PyErr_Occurred()) SWIG_fail;
28436 }
28437 resultobj = result;
28438 return resultobj;
28439 fail:
28440 return NULL;
28441 }
28442
28443
28444 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28445 PyObject *obj;
28446 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28447 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28448 Py_INCREF(obj);
28449 return Py_BuildValue((char *)"");
28450 }
28451 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28452 PyObject *resultobj;
28453 wxURLDataObject *result;
28454 char *kwnames[] = {
28455 NULL
28456 };
28457
28458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28459 {
28460 PyThreadState* __tstate = wxPyBeginAllowThreads();
28461 result = (wxURLDataObject *)new wxURLDataObject();
28462
28463 wxPyEndAllowThreads(__tstate);
28464 if (PyErr_Occurred()) SWIG_fail;
28465 }
28466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28467 return resultobj;
28468 fail:
28469 return NULL;
28470 }
28471
28472
28473 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28474 PyObject *resultobj;
28475 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28476 wxString result;
28477 PyObject * obj0 = 0 ;
28478 char *kwnames[] = {
28479 (char *) "self", NULL
28480 };
28481
28482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28484 if (SWIG_arg_fail(1)) SWIG_fail;
28485 {
28486 PyThreadState* __tstate = wxPyBeginAllowThreads();
28487 result = (arg1)->GetURL();
28488
28489 wxPyEndAllowThreads(__tstate);
28490 if (PyErr_Occurred()) SWIG_fail;
28491 }
28492 {
28493 #if wxUSE_UNICODE
28494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28495 #else
28496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28497 #endif
28498 }
28499 return resultobj;
28500 fail:
28501 return NULL;
28502 }
28503
28504
28505 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28506 PyObject *resultobj;
28507 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28508 wxString *arg2 = 0 ;
28509 bool temp2 = false ;
28510 PyObject * obj0 = 0 ;
28511 PyObject * obj1 = 0 ;
28512 char *kwnames[] = {
28513 (char *) "self",(char *) "url", NULL
28514 };
28515
28516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28518 if (SWIG_arg_fail(1)) SWIG_fail;
28519 {
28520 arg2 = wxString_in_helper(obj1);
28521 if (arg2 == NULL) SWIG_fail;
28522 temp2 = true;
28523 }
28524 {
28525 PyThreadState* __tstate = wxPyBeginAllowThreads();
28526 (arg1)->SetURL((wxString const &)*arg2);
28527
28528 wxPyEndAllowThreads(__tstate);
28529 if (PyErr_Occurred()) SWIG_fail;
28530 }
28531 Py_INCREF(Py_None); resultobj = Py_None;
28532 {
28533 if (temp2)
28534 delete arg2;
28535 }
28536 return resultobj;
28537 fail:
28538 {
28539 if (temp2)
28540 delete arg2;
28541 }
28542 return NULL;
28543 }
28544
28545
28546 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28547 PyObject *obj;
28548 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28549 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28550 Py_INCREF(obj);
28551 return Py_BuildValue((char *)"");
28552 }
28553 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28554 PyObject *resultobj;
28555 wxMetafileDataObject *result;
28556 char *kwnames[] = {
28557 NULL
28558 };
28559
28560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28561 {
28562 PyThreadState* __tstate = wxPyBeginAllowThreads();
28563 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28564
28565 wxPyEndAllowThreads(__tstate);
28566 if (PyErr_Occurred()) SWIG_fail;
28567 }
28568 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28569 return resultobj;
28570 fail:
28571 return NULL;
28572 }
28573
28574
28575 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28576 PyObject *obj;
28577 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28578 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28579 Py_INCREF(obj);
28580 return Py_BuildValue((char *)"");
28581 }
28582 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28583 PyObject *resultobj;
28584 wxDragResult arg1 ;
28585 bool result;
28586 PyObject * obj0 = 0 ;
28587 char *kwnames[] = {
28588 (char *) "res", NULL
28589 };
28590
28591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28592 {
28593 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28594 if (SWIG_arg_fail(1)) SWIG_fail;
28595 }
28596 {
28597 PyThreadState* __tstate = wxPyBeginAllowThreads();
28598 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28599
28600 wxPyEndAllowThreads(__tstate);
28601 if (PyErr_Occurred()) SWIG_fail;
28602 }
28603 {
28604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28605 }
28606 return resultobj;
28607 fail:
28608 return NULL;
28609 }
28610
28611
28612 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28613 PyObject *resultobj;
28614 wxWindow *arg1 = (wxWindow *) 0 ;
28615 wxIcon const &arg2_defvalue = wxNullIcon ;
28616 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28617 wxIcon const &arg3_defvalue = wxNullIcon ;
28618 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28619 wxIcon const &arg4_defvalue = wxNullIcon ;
28620 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28621 wxPyDropSource *result;
28622 PyObject * obj0 = 0 ;
28623 PyObject * obj1 = 0 ;
28624 PyObject * obj2 = 0 ;
28625 PyObject * obj3 = 0 ;
28626 char *kwnames[] = {
28627 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28628 };
28629
28630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28632 if (SWIG_arg_fail(1)) SWIG_fail;
28633 if (obj1) {
28634 {
28635 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28636 if (SWIG_arg_fail(2)) SWIG_fail;
28637 if (arg2 == NULL) {
28638 SWIG_null_ref("wxIcon");
28639 }
28640 if (SWIG_arg_fail(2)) SWIG_fail;
28641 }
28642 }
28643 if (obj2) {
28644 {
28645 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28646 if (SWIG_arg_fail(3)) SWIG_fail;
28647 if (arg3 == NULL) {
28648 SWIG_null_ref("wxIcon");
28649 }
28650 if (SWIG_arg_fail(3)) SWIG_fail;
28651 }
28652 }
28653 if (obj3) {
28654 {
28655 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28656 if (SWIG_arg_fail(4)) SWIG_fail;
28657 if (arg4 == NULL) {
28658 SWIG_null_ref("wxIcon");
28659 }
28660 if (SWIG_arg_fail(4)) SWIG_fail;
28661 }
28662 }
28663 {
28664 PyThreadState* __tstate = wxPyBeginAllowThreads();
28665 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28666
28667 wxPyEndAllowThreads(__tstate);
28668 if (PyErr_Occurred()) SWIG_fail;
28669 }
28670 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28671 return resultobj;
28672 fail:
28673 return NULL;
28674 }
28675
28676
28677 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28678 PyObject *resultobj;
28679 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28680 PyObject *arg2 = (PyObject *) 0 ;
28681 PyObject *arg3 = (PyObject *) 0 ;
28682 int arg4 ;
28683 PyObject * obj0 = 0 ;
28684 PyObject * obj1 = 0 ;
28685 PyObject * obj2 = 0 ;
28686 PyObject * obj3 = 0 ;
28687 char *kwnames[] = {
28688 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28689 };
28690
28691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28693 if (SWIG_arg_fail(1)) SWIG_fail;
28694 arg2 = obj1;
28695 arg3 = obj2;
28696 {
28697 arg4 = (int)(SWIG_As_int(obj3));
28698 if (SWIG_arg_fail(4)) SWIG_fail;
28699 }
28700 {
28701 PyThreadState* __tstate = wxPyBeginAllowThreads();
28702 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28703
28704 wxPyEndAllowThreads(__tstate);
28705 if (PyErr_Occurred()) SWIG_fail;
28706 }
28707 Py_INCREF(Py_None); resultobj = Py_None;
28708 return resultobj;
28709 fail:
28710 return NULL;
28711 }
28712
28713
28714 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28715 PyObject *resultobj;
28716 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28717 PyObject * obj0 = 0 ;
28718 char *kwnames[] = {
28719 (char *) "self", NULL
28720 };
28721
28722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28724 if (SWIG_arg_fail(1)) SWIG_fail;
28725 {
28726 PyThreadState* __tstate = wxPyBeginAllowThreads();
28727 delete arg1;
28728
28729 wxPyEndAllowThreads(__tstate);
28730 if (PyErr_Occurred()) SWIG_fail;
28731 }
28732 Py_INCREF(Py_None); resultobj = Py_None;
28733 return resultobj;
28734 fail:
28735 return NULL;
28736 }
28737
28738
28739 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28740 PyObject *resultobj;
28741 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28742 wxDataObject *arg2 = 0 ;
28743 PyObject * obj0 = 0 ;
28744 PyObject * obj1 = 0 ;
28745 char *kwnames[] = {
28746 (char *) "self",(char *) "data", NULL
28747 };
28748
28749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28751 if (SWIG_arg_fail(1)) SWIG_fail;
28752 {
28753 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28754 if (SWIG_arg_fail(2)) SWIG_fail;
28755 if (arg2 == NULL) {
28756 SWIG_null_ref("wxDataObject");
28757 }
28758 if (SWIG_arg_fail(2)) SWIG_fail;
28759 }
28760 {
28761 PyThreadState* __tstate = wxPyBeginAllowThreads();
28762 (arg1)->SetData(*arg2);
28763
28764 wxPyEndAllowThreads(__tstate);
28765 if (PyErr_Occurred()) SWIG_fail;
28766 }
28767 Py_INCREF(Py_None); resultobj = Py_None;
28768 return resultobj;
28769 fail:
28770 return NULL;
28771 }
28772
28773
28774 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28775 PyObject *resultobj;
28776 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28777 wxDataObject *result;
28778 PyObject * obj0 = 0 ;
28779 char *kwnames[] = {
28780 (char *) "self", NULL
28781 };
28782
28783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28785 if (SWIG_arg_fail(1)) SWIG_fail;
28786 {
28787 PyThreadState* __tstate = wxPyBeginAllowThreads();
28788 result = (wxDataObject *)(arg1)->GetDataObject();
28789
28790 wxPyEndAllowThreads(__tstate);
28791 if (PyErr_Occurred()) SWIG_fail;
28792 }
28793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28794 return resultobj;
28795 fail:
28796 return NULL;
28797 }
28798
28799
28800 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28801 PyObject *resultobj;
28802 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28803 wxDragResult arg2 ;
28804 wxCursor *arg3 = 0 ;
28805 PyObject * obj0 = 0 ;
28806 PyObject * obj1 = 0 ;
28807 PyObject * obj2 = 0 ;
28808 char *kwnames[] = {
28809 (char *) "self",(char *) "res",(char *) "cursor", NULL
28810 };
28811
28812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28814 if (SWIG_arg_fail(1)) SWIG_fail;
28815 {
28816 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28817 if (SWIG_arg_fail(2)) SWIG_fail;
28818 }
28819 {
28820 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28821 if (SWIG_arg_fail(3)) SWIG_fail;
28822 if (arg3 == NULL) {
28823 SWIG_null_ref("wxCursor");
28824 }
28825 if (SWIG_arg_fail(3)) SWIG_fail;
28826 }
28827 {
28828 PyThreadState* __tstate = wxPyBeginAllowThreads();
28829 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28830
28831 wxPyEndAllowThreads(__tstate);
28832 if (PyErr_Occurred()) SWIG_fail;
28833 }
28834 Py_INCREF(Py_None); resultobj = Py_None;
28835 return resultobj;
28836 fail:
28837 return NULL;
28838 }
28839
28840
28841 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28842 PyObject *resultobj;
28843 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28844 int arg2 = (int) wxDrag_CopyOnly ;
28845 wxDragResult result;
28846 PyObject * obj0 = 0 ;
28847 PyObject * obj1 = 0 ;
28848 char *kwnames[] = {
28849 (char *) "self",(char *) "flags", NULL
28850 };
28851
28852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28854 if (SWIG_arg_fail(1)) SWIG_fail;
28855 if (obj1) {
28856 {
28857 arg2 = (int)(SWIG_As_int(obj1));
28858 if (SWIG_arg_fail(2)) SWIG_fail;
28859 }
28860 }
28861 {
28862 PyThreadState* __tstate = wxPyBeginAllowThreads();
28863 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28864
28865 wxPyEndAllowThreads(__tstate);
28866 if (PyErr_Occurred()) SWIG_fail;
28867 }
28868 resultobj = SWIG_From_int((result));
28869 return resultobj;
28870 fail:
28871 return NULL;
28872 }
28873
28874
28875 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28876 PyObject *resultobj;
28877 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28878 wxDragResult arg2 ;
28879 bool result;
28880 PyObject * obj0 = 0 ;
28881 PyObject * obj1 = 0 ;
28882 char *kwnames[] = {
28883 (char *) "self",(char *) "effect", NULL
28884 };
28885
28886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28888 if (SWIG_arg_fail(1)) SWIG_fail;
28889 {
28890 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28891 if (SWIG_arg_fail(2)) SWIG_fail;
28892 }
28893 {
28894 PyThreadState* __tstate = wxPyBeginAllowThreads();
28895 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28896
28897 wxPyEndAllowThreads(__tstate);
28898 if (PyErr_Occurred()) SWIG_fail;
28899 }
28900 {
28901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28902 }
28903 return resultobj;
28904 fail:
28905 return NULL;
28906 }
28907
28908
28909 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28910 PyObject *obj;
28911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28912 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28913 Py_INCREF(obj);
28914 return Py_BuildValue((char *)"");
28915 }
28916 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28917 PyObject *resultobj;
28918 wxDataObject *arg1 = (wxDataObject *) NULL ;
28919 wxPyDropTarget *result;
28920 PyObject * obj0 = 0 ;
28921 char *kwnames[] = {
28922 (char *) "dataObject", NULL
28923 };
28924
28925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28926 if (obj0) {
28927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28928 if (SWIG_arg_fail(1)) SWIG_fail;
28929 }
28930 {
28931 PyThreadState* __tstate = wxPyBeginAllowThreads();
28932 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28933
28934 wxPyEndAllowThreads(__tstate);
28935 if (PyErr_Occurred()) SWIG_fail;
28936 }
28937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28938 return resultobj;
28939 fail:
28940 return NULL;
28941 }
28942
28943
28944 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28945 PyObject *resultobj;
28946 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28947 PyObject *arg2 = (PyObject *) 0 ;
28948 PyObject *arg3 = (PyObject *) 0 ;
28949 PyObject * obj0 = 0 ;
28950 PyObject * obj1 = 0 ;
28951 PyObject * obj2 = 0 ;
28952 char *kwnames[] = {
28953 (char *) "self",(char *) "self",(char *) "_class", NULL
28954 };
28955
28956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28958 if (SWIG_arg_fail(1)) SWIG_fail;
28959 arg2 = obj1;
28960 arg3 = obj2;
28961 {
28962 PyThreadState* __tstate = wxPyBeginAllowThreads();
28963 (arg1)->_setCallbackInfo(arg2,arg3);
28964
28965 wxPyEndAllowThreads(__tstate);
28966 if (PyErr_Occurred()) SWIG_fail;
28967 }
28968 Py_INCREF(Py_None); resultobj = Py_None;
28969 return resultobj;
28970 fail:
28971 return NULL;
28972 }
28973
28974
28975 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28976 PyObject *resultobj;
28977 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28978 PyObject * obj0 = 0 ;
28979 char *kwnames[] = {
28980 (char *) "self", NULL
28981 };
28982
28983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28985 if (SWIG_arg_fail(1)) SWIG_fail;
28986 {
28987 PyThreadState* __tstate = wxPyBeginAllowThreads();
28988 delete arg1;
28989
28990 wxPyEndAllowThreads(__tstate);
28991 if (PyErr_Occurred()) SWIG_fail;
28992 }
28993 Py_INCREF(Py_None); resultobj = Py_None;
28994 return resultobj;
28995 fail:
28996 return NULL;
28997 }
28998
28999
29000 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29001 PyObject *resultobj;
29002 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29003 wxDataObject *result;
29004 PyObject * obj0 = 0 ;
29005 char *kwnames[] = {
29006 (char *) "self", NULL
29007 };
29008
29009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
29010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29011 if (SWIG_arg_fail(1)) SWIG_fail;
29012 {
29013 PyThreadState* __tstate = wxPyBeginAllowThreads();
29014 result = (wxDataObject *)(arg1)->GetDataObject();
29015
29016 wxPyEndAllowThreads(__tstate);
29017 if (PyErr_Occurred()) SWIG_fail;
29018 }
29019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29020 return resultobj;
29021 fail:
29022 return NULL;
29023 }
29024
29025
29026 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29027 PyObject *resultobj;
29028 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29029 wxDataObject *arg2 = (wxDataObject *) 0 ;
29030 PyObject * obj0 = 0 ;
29031 PyObject * obj1 = 0 ;
29032 char *kwnames[] = {
29033 (char *) "self",(char *) "dataObject", NULL
29034 };
29035
29036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29038 if (SWIG_arg_fail(1)) SWIG_fail;
29039 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29040 if (SWIG_arg_fail(2)) SWIG_fail;
29041 {
29042 PyThreadState* __tstate = wxPyBeginAllowThreads();
29043 (arg1)->SetDataObject(arg2);
29044
29045 wxPyEndAllowThreads(__tstate);
29046 if (PyErr_Occurred()) SWIG_fail;
29047 }
29048 Py_INCREF(Py_None); resultobj = Py_None;
29049 return resultobj;
29050 fail:
29051 return NULL;
29052 }
29053
29054
29055 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29056 PyObject *resultobj;
29057 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29058 int arg2 ;
29059 int arg3 ;
29060 wxDragResult arg4 ;
29061 wxDragResult result;
29062 PyObject * obj0 = 0 ;
29063 PyObject * obj1 = 0 ;
29064 PyObject * obj2 = 0 ;
29065 PyObject * obj3 = 0 ;
29066 char *kwnames[] = {
29067 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29068 };
29069
29070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29072 if (SWIG_arg_fail(1)) SWIG_fail;
29073 {
29074 arg2 = (int)(SWIG_As_int(obj1));
29075 if (SWIG_arg_fail(2)) SWIG_fail;
29076 }
29077 {
29078 arg3 = (int)(SWIG_As_int(obj2));
29079 if (SWIG_arg_fail(3)) SWIG_fail;
29080 }
29081 {
29082 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29083 if (SWIG_arg_fail(4)) SWIG_fail;
29084 }
29085 {
29086 PyThreadState* __tstate = wxPyBeginAllowThreads();
29087 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29088
29089 wxPyEndAllowThreads(__tstate);
29090 if (PyErr_Occurred()) SWIG_fail;
29091 }
29092 resultobj = SWIG_From_int((result));
29093 return resultobj;
29094 fail:
29095 return NULL;
29096 }
29097
29098
29099 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29100 PyObject *resultobj;
29101 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29102 int arg2 ;
29103 int arg3 ;
29104 wxDragResult arg4 ;
29105 wxDragResult result;
29106 PyObject * obj0 = 0 ;
29107 PyObject * obj1 = 0 ;
29108 PyObject * obj2 = 0 ;
29109 PyObject * obj3 = 0 ;
29110 char *kwnames[] = {
29111 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29112 };
29113
29114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29116 if (SWIG_arg_fail(1)) SWIG_fail;
29117 {
29118 arg2 = (int)(SWIG_As_int(obj1));
29119 if (SWIG_arg_fail(2)) SWIG_fail;
29120 }
29121 {
29122 arg3 = (int)(SWIG_As_int(obj2));
29123 if (SWIG_arg_fail(3)) SWIG_fail;
29124 }
29125 {
29126 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29127 if (SWIG_arg_fail(4)) SWIG_fail;
29128 }
29129 {
29130 PyThreadState* __tstate = wxPyBeginAllowThreads();
29131 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29132
29133 wxPyEndAllowThreads(__tstate);
29134 if (PyErr_Occurred()) SWIG_fail;
29135 }
29136 resultobj = SWIG_From_int((result));
29137 return resultobj;
29138 fail:
29139 return NULL;
29140 }
29141
29142
29143 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29144 PyObject *resultobj;
29145 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29146 PyObject * obj0 = 0 ;
29147 char *kwnames[] = {
29148 (char *) "self", NULL
29149 };
29150
29151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29153 if (SWIG_arg_fail(1)) SWIG_fail;
29154 {
29155 PyThreadState* __tstate = wxPyBeginAllowThreads();
29156 (arg1)->base_OnLeave();
29157
29158 wxPyEndAllowThreads(__tstate);
29159 if (PyErr_Occurred()) SWIG_fail;
29160 }
29161 Py_INCREF(Py_None); resultobj = Py_None;
29162 return resultobj;
29163 fail:
29164 return NULL;
29165 }
29166
29167
29168 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29169 PyObject *resultobj;
29170 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29171 int arg2 ;
29172 int arg3 ;
29173 bool result;
29174 PyObject * obj0 = 0 ;
29175 PyObject * obj1 = 0 ;
29176 PyObject * obj2 = 0 ;
29177 char *kwnames[] = {
29178 (char *) "self",(char *) "x",(char *) "y", NULL
29179 };
29180
29181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29183 if (SWIG_arg_fail(1)) SWIG_fail;
29184 {
29185 arg2 = (int)(SWIG_As_int(obj1));
29186 if (SWIG_arg_fail(2)) SWIG_fail;
29187 }
29188 {
29189 arg3 = (int)(SWIG_As_int(obj2));
29190 if (SWIG_arg_fail(3)) SWIG_fail;
29191 }
29192 {
29193 PyThreadState* __tstate = wxPyBeginAllowThreads();
29194 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29195
29196 wxPyEndAllowThreads(__tstate);
29197 if (PyErr_Occurred()) SWIG_fail;
29198 }
29199 {
29200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29201 }
29202 return resultobj;
29203 fail:
29204 return NULL;
29205 }
29206
29207
29208 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29209 PyObject *resultobj;
29210 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29211 bool result;
29212 PyObject * obj0 = 0 ;
29213 char *kwnames[] = {
29214 (char *) "self", NULL
29215 };
29216
29217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29219 if (SWIG_arg_fail(1)) SWIG_fail;
29220 {
29221 PyThreadState* __tstate = wxPyBeginAllowThreads();
29222 result = (bool)(arg1)->GetData();
29223
29224 wxPyEndAllowThreads(__tstate);
29225 if (PyErr_Occurred()) SWIG_fail;
29226 }
29227 {
29228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29229 }
29230 return resultobj;
29231 fail:
29232 return NULL;
29233 }
29234
29235
29236 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29237 PyObject *resultobj;
29238 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29239 wxDragResult arg2 ;
29240 PyObject * obj0 = 0 ;
29241 PyObject * obj1 = 0 ;
29242 char *kwnames[] = {
29243 (char *) "self",(char *) "action", NULL
29244 };
29245
29246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29248 if (SWIG_arg_fail(1)) SWIG_fail;
29249 {
29250 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29251 if (SWIG_arg_fail(2)) SWIG_fail;
29252 }
29253 {
29254 PyThreadState* __tstate = wxPyBeginAllowThreads();
29255 (arg1)->SetDefaultAction((wxDragResult )arg2);
29256
29257 wxPyEndAllowThreads(__tstate);
29258 if (PyErr_Occurred()) SWIG_fail;
29259 }
29260 Py_INCREF(Py_None); resultobj = Py_None;
29261 return resultobj;
29262 fail:
29263 return NULL;
29264 }
29265
29266
29267 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29268 PyObject *resultobj;
29269 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29270 wxDragResult result;
29271 PyObject * obj0 = 0 ;
29272 char *kwnames[] = {
29273 (char *) "self", NULL
29274 };
29275
29276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29278 if (SWIG_arg_fail(1)) SWIG_fail;
29279 {
29280 PyThreadState* __tstate = wxPyBeginAllowThreads();
29281 result = (wxDragResult)(arg1)->GetDefaultAction();
29282
29283 wxPyEndAllowThreads(__tstate);
29284 if (PyErr_Occurred()) SWIG_fail;
29285 }
29286 resultobj = SWIG_From_int((result));
29287 return resultobj;
29288 fail:
29289 return NULL;
29290 }
29291
29292
29293 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29294 PyObject *obj;
29295 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29296 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29297 Py_INCREF(obj);
29298 return Py_BuildValue((char *)"");
29299 }
29300 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29301 PyObject *resultobj;
29302 wxPyTextDropTarget *result;
29303 char *kwnames[] = {
29304 NULL
29305 };
29306
29307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29308 {
29309 PyThreadState* __tstate = wxPyBeginAllowThreads();
29310 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29311
29312 wxPyEndAllowThreads(__tstate);
29313 if (PyErr_Occurred()) SWIG_fail;
29314 }
29315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29316 return resultobj;
29317 fail:
29318 return NULL;
29319 }
29320
29321
29322 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29323 PyObject *resultobj;
29324 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29325 PyObject *arg2 = (PyObject *) 0 ;
29326 PyObject *arg3 = (PyObject *) 0 ;
29327 PyObject * obj0 = 0 ;
29328 PyObject * obj1 = 0 ;
29329 PyObject * obj2 = 0 ;
29330 char *kwnames[] = {
29331 (char *) "self",(char *) "self",(char *) "_class", NULL
29332 };
29333
29334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29336 if (SWIG_arg_fail(1)) SWIG_fail;
29337 arg2 = obj1;
29338 arg3 = obj2;
29339 {
29340 PyThreadState* __tstate = wxPyBeginAllowThreads();
29341 (arg1)->_setCallbackInfo(arg2,arg3);
29342
29343 wxPyEndAllowThreads(__tstate);
29344 if (PyErr_Occurred()) SWIG_fail;
29345 }
29346 Py_INCREF(Py_None); resultobj = Py_None;
29347 return resultobj;
29348 fail:
29349 return NULL;
29350 }
29351
29352
29353 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29354 PyObject *resultobj;
29355 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29356 int arg2 ;
29357 int arg3 ;
29358 wxDragResult arg4 ;
29359 wxDragResult result;
29360 PyObject * obj0 = 0 ;
29361 PyObject * obj1 = 0 ;
29362 PyObject * obj2 = 0 ;
29363 PyObject * obj3 = 0 ;
29364 char *kwnames[] = {
29365 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29366 };
29367
29368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29370 if (SWIG_arg_fail(1)) SWIG_fail;
29371 {
29372 arg2 = (int)(SWIG_As_int(obj1));
29373 if (SWIG_arg_fail(2)) SWIG_fail;
29374 }
29375 {
29376 arg3 = (int)(SWIG_As_int(obj2));
29377 if (SWIG_arg_fail(3)) SWIG_fail;
29378 }
29379 {
29380 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29381 if (SWIG_arg_fail(4)) SWIG_fail;
29382 }
29383 {
29384 PyThreadState* __tstate = wxPyBeginAllowThreads();
29385 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29386
29387 wxPyEndAllowThreads(__tstate);
29388 if (PyErr_Occurred()) SWIG_fail;
29389 }
29390 resultobj = SWIG_From_int((result));
29391 return resultobj;
29392 fail:
29393 return NULL;
29394 }
29395
29396
29397 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29398 PyObject *resultobj;
29399 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29400 int arg2 ;
29401 int arg3 ;
29402 wxDragResult arg4 ;
29403 wxDragResult result;
29404 PyObject * obj0 = 0 ;
29405 PyObject * obj1 = 0 ;
29406 PyObject * obj2 = 0 ;
29407 PyObject * obj3 = 0 ;
29408 char *kwnames[] = {
29409 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29410 };
29411
29412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29414 if (SWIG_arg_fail(1)) SWIG_fail;
29415 {
29416 arg2 = (int)(SWIG_As_int(obj1));
29417 if (SWIG_arg_fail(2)) SWIG_fail;
29418 }
29419 {
29420 arg3 = (int)(SWIG_As_int(obj2));
29421 if (SWIG_arg_fail(3)) SWIG_fail;
29422 }
29423 {
29424 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29425 if (SWIG_arg_fail(4)) SWIG_fail;
29426 }
29427 {
29428 PyThreadState* __tstate = wxPyBeginAllowThreads();
29429 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29430
29431 wxPyEndAllowThreads(__tstate);
29432 if (PyErr_Occurred()) SWIG_fail;
29433 }
29434 resultobj = SWIG_From_int((result));
29435 return resultobj;
29436 fail:
29437 return NULL;
29438 }
29439
29440
29441 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29442 PyObject *resultobj;
29443 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29444 PyObject * obj0 = 0 ;
29445 char *kwnames[] = {
29446 (char *) "self", NULL
29447 };
29448
29449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29451 if (SWIG_arg_fail(1)) SWIG_fail;
29452 {
29453 PyThreadState* __tstate = wxPyBeginAllowThreads();
29454 (arg1)->base_OnLeave();
29455
29456 wxPyEndAllowThreads(__tstate);
29457 if (PyErr_Occurred()) SWIG_fail;
29458 }
29459 Py_INCREF(Py_None); resultobj = Py_None;
29460 return resultobj;
29461 fail:
29462 return NULL;
29463 }
29464
29465
29466 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29467 PyObject *resultobj;
29468 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29469 int arg2 ;
29470 int arg3 ;
29471 bool result;
29472 PyObject * obj0 = 0 ;
29473 PyObject * obj1 = 0 ;
29474 PyObject * obj2 = 0 ;
29475 char *kwnames[] = {
29476 (char *) "self",(char *) "x",(char *) "y", NULL
29477 };
29478
29479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29481 if (SWIG_arg_fail(1)) SWIG_fail;
29482 {
29483 arg2 = (int)(SWIG_As_int(obj1));
29484 if (SWIG_arg_fail(2)) SWIG_fail;
29485 }
29486 {
29487 arg3 = (int)(SWIG_As_int(obj2));
29488 if (SWIG_arg_fail(3)) SWIG_fail;
29489 }
29490 {
29491 PyThreadState* __tstate = wxPyBeginAllowThreads();
29492 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29493
29494 wxPyEndAllowThreads(__tstate);
29495 if (PyErr_Occurred()) SWIG_fail;
29496 }
29497 {
29498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29499 }
29500 return resultobj;
29501 fail:
29502 return NULL;
29503 }
29504
29505
29506 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29507 PyObject *resultobj;
29508 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29509 int arg2 ;
29510 int arg3 ;
29511 wxDragResult arg4 ;
29512 wxDragResult result;
29513 PyObject * obj0 = 0 ;
29514 PyObject * obj1 = 0 ;
29515 PyObject * obj2 = 0 ;
29516 PyObject * obj3 = 0 ;
29517 char *kwnames[] = {
29518 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29519 };
29520
29521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29523 if (SWIG_arg_fail(1)) SWIG_fail;
29524 {
29525 arg2 = (int)(SWIG_As_int(obj1));
29526 if (SWIG_arg_fail(2)) SWIG_fail;
29527 }
29528 {
29529 arg3 = (int)(SWIG_As_int(obj2));
29530 if (SWIG_arg_fail(3)) SWIG_fail;
29531 }
29532 {
29533 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29534 if (SWIG_arg_fail(4)) SWIG_fail;
29535 }
29536 {
29537 PyThreadState* __tstate = wxPyBeginAllowThreads();
29538 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29539
29540 wxPyEndAllowThreads(__tstate);
29541 if (PyErr_Occurred()) SWIG_fail;
29542 }
29543 resultobj = SWIG_From_int((result));
29544 return resultobj;
29545 fail:
29546 return NULL;
29547 }
29548
29549
29550 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29551 PyObject *obj;
29552 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29553 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29554 Py_INCREF(obj);
29555 return Py_BuildValue((char *)"");
29556 }
29557 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29558 PyObject *resultobj;
29559 wxPyFileDropTarget *result;
29560 char *kwnames[] = {
29561 NULL
29562 };
29563
29564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29565 {
29566 PyThreadState* __tstate = wxPyBeginAllowThreads();
29567 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29568
29569 wxPyEndAllowThreads(__tstate);
29570 if (PyErr_Occurred()) SWIG_fail;
29571 }
29572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29573 return resultobj;
29574 fail:
29575 return NULL;
29576 }
29577
29578
29579 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29580 PyObject *resultobj;
29581 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29582 PyObject *arg2 = (PyObject *) 0 ;
29583 PyObject *arg3 = (PyObject *) 0 ;
29584 PyObject * obj0 = 0 ;
29585 PyObject * obj1 = 0 ;
29586 PyObject * obj2 = 0 ;
29587 char *kwnames[] = {
29588 (char *) "self",(char *) "self",(char *) "_class", NULL
29589 };
29590
29591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29593 if (SWIG_arg_fail(1)) SWIG_fail;
29594 arg2 = obj1;
29595 arg3 = obj2;
29596 {
29597 PyThreadState* __tstate = wxPyBeginAllowThreads();
29598 (arg1)->_setCallbackInfo(arg2,arg3);
29599
29600 wxPyEndAllowThreads(__tstate);
29601 if (PyErr_Occurred()) SWIG_fail;
29602 }
29603 Py_INCREF(Py_None); resultobj = Py_None;
29604 return resultobj;
29605 fail:
29606 return NULL;
29607 }
29608
29609
29610 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29611 PyObject *resultobj;
29612 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29613 int arg2 ;
29614 int arg3 ;
29615 wxDragResult arg4 ;
29616 wxDragResult result;
29617 PyObject * obj0 = 0 ;
29618 PyObject * obj1 = 0 ;
29619 PyObject * obj2 = 0 ;
29620 PyObject * obj3 = 0 ;
29621 char *kwnames[] = {
29622 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29623 };
29624
29625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29627 if (SWIG_arg_fail(1)) SWIG_fail;
29628 {
29629 arg2 = (int)(SWIG_As_int(obj1));
29630 if (SWIG_arg_fail(2)) SWIG_fail;
29631 }
29632 {
29633 arg3 = (int)(SWIG_As_int(obj2));
29634 if (SWIG_arg_fail(3)) SWIG_fail;
29635 }
29636 {
29637 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29638 if (SWIG_arg_fail(4)) SWIG_fail;
29639 }
29640 {
29641 PyThreadState* __tstate = wxPyBeginAllowThreads();
29642 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29643
29644 wxPyEndAllowThreads(__tstate);
29645 if (PyErr_Occurred()) SWIG_fail;
29646 }
29647 resultobj = SWIG_From_int((result));
29648 return resultobj;
29649 fail:
29650 return NULL;
29651 }
29652
29653
29654 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29655 PyObject *resultobj;
29656 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29657 int arg2 ;
29658 int arg3 ;
29659 wxDragResult arg4 ;
29660 wxDragResult result;
29661 PyObject * obj0 = 0 ;
29662 PyObject * obj1 = 0 ;
29663 PyObject * obj2 = 0 ;
29664 PyObject * obj3 = 0 ;
29665 char *kwnames[] = {
29666 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29667 };
29668
29669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29671 if (SWIG_arg_fail(1)) SWIG_fail;
29672 {
29673 arg2 = (int)(SWIG_As_int(obj1));
29674 if (SWIG_arg_fail(2)) SWIG_fail;
29675 }
29676 {
29677 arg3 = (int)(SWIG_As_int(obj2));
29678 if (SWIG_arg_fail(3)) SWIG_fail;
29679 }
29680 {
29681 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29682 if (SWIG_arg_fail(4)) SWIG_fail;
29683 }
29684 {
29685 PyThreadState* __tstate = wxPyBeginAllowThreads();
29686 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29687
29688 wxPyEndAllowThreads(__tstate);
29689 if (PyErr_Occurred()) SWIG_fail;
29690 }
29691 resultobj = SWIG_From_int((result));
29692 return resultobj;
29693 fail:
29694 return NULL;
29695 }
29696
29697
29698 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29699 PyObject *resultobj;
29700 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29701 PyObject * obj0 = 0 ;
29702 char *kwnames[] = {
29703 (char *) "self", NULL
29704 };
29705
29706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29708 if (SWIG_arg_fail(1)) SWIG_fail;
29709 {
29710 PyThreadState* __tstate = wxPyBeginAllowThreads();
29711 (arg1)->base_OnLeave();
29712
29713 wxPyEndAllowThreads(__tstate);
29714 if (PyErr_Occurred()) SWIG_fail;
29715 }
29716 Py_INCREF(Py_None); resultobj = Py_None;
29717 return resultobj;
29718 fail:
29719 return NULL;
29720 }
29721
29722
29723 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29724 PyObject *resultobj;
29725 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29726 int arg2 ;
29727 int arg3 ;
29728 bool result;
29729 PyObject * obj0 = 0 ;
29730 PyObject * obj1 = 0 ;
29731 PyObject * obj2 = 0 ;
29732 char *kwnames[] = {
29733 (char *) "self",(char *) "x",(char *) "y", NULL
29734 };
29735
29736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29738 if (SWIG_arg_fail(1)) SWIG_fail;
29739 {
29740 arg2 = (int)(SWIG_As_int(obj1));
29741 if (SWIG_arg_fail(2)) SWIG_fail;
29742 }
29743 {
29744 arg3 = (int)(SWIG_As_int(obj2));
29745 if (SWIG_arg_fail(3)) SWIG_fail;
29746 }
29747 {
29748 PyThreadState* __tstate = wxPyBeginAllowThreads();
29749 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29750
29751 wxPyEndAllowThreads(__tstate);
29752 if (PyErr_Occurred()) SWIG_fail;
29753 }
29754 {
29755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29756 }
29757 return resultobj;
29758 fail:
29759 return NULL;
29760 }
29761
29762
29763 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29764 PyObject *resultobj;
29765 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29766 int arg2 ;
29767 int arg3 ;
29768 wxDragResult arg4 ;
29769 wxDragResult result;
29770 PyObject * obj0 = 0 ;
29771 PyObject * obj1 = 0 ;
29772 PyObject * obj2 = 0 ;
29773 PyObject * obj3 = 0 ;
29774 char *kwnames[] = {
29775 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29776 };
29777
29778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29780 if (SWIG_arg_fail(1)) SWIG_fail;
29781 {
29782 arg2 = (int)(SWIG_As_int(obj1));
29783 if (SWIG_arg_fail(2)) SWIG_fail;
29784 }
29785 {
29786 arg3 = (int)(SWIG_As_int(obj2));
29787 if (SWIG_arg_fail(3)) SWIG_fail;
29788 }
29789 {
29790 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29791 if (SWIG_arg_fail(4)) SWIG_fail;
29792 }
29793 {
29794 PyThreadState* __tstate = wxPyBeginAllowThreads();
29795 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29796
29797 wxPyEndAllowThreads(__tstate);
29798 if (PyErr_Occurred()) SWIG_fail;
29799 }
29800 resultobj = SWIG_From_int((result));
29801 return resultobj;
29802 fail:
29803 return NULL;
29804 }
29805
29806
29807 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29808 PyObject *obj;
29809 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29810 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29811 Py_INCREF(obj);
29812 return Py_BuildValue((char *)"");
29813 }
29814 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29815 PyObject *resultobj;
29816 wxClipboard *result;
29817 char *kwnames[] = {
29818 NULL
29819 };
29820
29821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29822 {
29823 PyThreadState* __tstate = wxPyBeginAllowThreads();
29824 result = (wxClipboard *)new wxClipboard();
29825
29826 wxPyEndAllowThreads(__tstate);
29827 if (PyErr_Occurred()) SWIG_fail;
29828 }
29829 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29830 return resultobj;
29831 fail:
29832 return NULL;
29833 }
29834
29835
29836 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29837 PyObject *resultobj;
29838 wxClipboard *arg1 = (wxClipboard *) 0 ;
29839 PyObject * obj0 = 0 ;
29840 char *kwnames[] = {
29841 (char *) "self", NULL
29842 };
29843
29844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29846 if (SWIG_arg_fail(1)) SWIG_fail;
29847 {
29848 PyThreadState* __tstate = wxPyBeginAllowThreads();
29849 delete arg1;
29850
29851 wxPyEndAllowThreads(__tstate);
29852 if (PyErr_Occurred()) SWIG_fail;
29853 }
29854 Py_INCREF(Py_None); resultobj = Py_None;
29855 return resultobj;
29856 fail:
29857 return NULL;
29858 }
29859
29860
29861 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29862 PyObject *resultobj;
29863 wxClipboard *arg1 = (wxClipboard *) 0 ;
29864 bool result;
29865 PyObject * obj0 = 0 ;
29866 char *kwnames[] = {
29867 (char *) "self", NULL
29868 };
29869
29870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29872 if (SWIG_arg_fail(1)) SWIG_fail;
29873 {
29874 PyThreadState* __tstate = wxPyBeginAllowThreads();
29875 result = (bool)(arg1)->Open();
29876
29877 wxPyEndAllowThreads(__tstate);
29878 if (PyErr_Occurred()) SWIG_fail;
29879 }
29880 {
29881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29882 }
29883 return resultobj;
29884 fail:
29885 return NULL;
29886 }
29887
29888
29889 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29890 PyObject *resultobj;
29891 wxClipboard *arg1 = (wxClipboard *) 0 ;
29892 PyObject * obj0 = 0 ;
29893 char *kwnames[] = {
29894 (char *) "self", NULL
29895 };
29896
29897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29899 if (SWIG_arg_fail(1)) SWIG_fail;
29900 {
29901 PyThreadState* __tstate = wxPyBeginAllowThreads();
29902 (arg1)->Close();
29903
29904 wxPyEndAllowThreads(__tstate);
29905 if (PyErr_Occurred()) SWIG_fail;
29906 }
29907 Py_INCREF(Py_None); resultobj = Py_None;
29908 return resultobj;
29909 fail:
29910 return NULL;
29911 }
29912
29913
29914 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29915 PyObject *resultobj;
29916 wxClipboard *arg1 = (wxClipboard *) 0 ;
29917 bool result;
29918 PyObject * obj0 = 0 ;
29919 char *kwnames[] = {
29920 (char *) "self", NULL
29921 };
29922
29923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29925 if (SWIG_arg_fail(1)) SWIG_fail;
29926 {
29927 PyThreadState* __tstate = wxPyBeginAllowThreads();
29928 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29929
29930 wxPyEndAllowThreads(__tstate);
29931 if (PyErr_Occurred()) SWIG_fail;
29932 }
29933 {
29934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29935 }
29936 return resultobj;
29937 fail:
29938 return NULL;
29939 }
29940
29941
29942 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29943 PyObject *resultobj;
29944 wxClipboard *arg1 = (wxClipboard *) 0 ;
29945 wxDataObject *arg2 = (wxDataObject *) 0 ;
29946 bool result;
29947 PyObject * obj0 = 0 ;
29948 PyObject * obj1 = 0 ;
29949 char *kwnames[] = {
29950 (char *) "self",(char *) "data", NULL
29951 };
29952
29953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29955 if (SWIG_arg_fail(1)) SWIG_fail;
29956 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29957 if (SWIG_arg_fail(2)) SWIG_fail;
29958 {
29959 PyThreadState* __tstate = wxPyBeginAllowThreads();
29960 result = (bool)(arg1)->AddData(arg2);
29961
29962 wxPyEndAllowThreads(__tstate);
29963 if (PyErr_Occurred()) SWIG_fail;
29964 }
29965 {
29966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29967 }
29968 return resultobj;
29969 fail:
29970 return NULL;
29971 }
29972
29973
29974 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29975 PyObject *resultobj;
29976 wxClipboard *arg1 = (wxClipboard *) 0 ;
29977 wxDataObject *arg2 = (wxDataObject *) 0 ;
29978 bool result;
29979 PyObject * obj0 = 0 ;
29980 PyObject * obj1 = 0 ;
29981 char *kwnames[] = {
29982 (char *) "self",(char *) "data", NULL
29983 };
29984
29985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29987 if (SWIG_arg_fail(1)) SWIG_fail;
29988 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29989 if (SWIG_arg_fail(2)) SWIG_fail;
29990 {
29991 PyThreadState* __tstate = wxPyBeginAllowThreads();
29992 result = (bool)(arg1)->SetData(arg2);
29993
29994 wxPyEndAllowThreads(__tstate);
29995 if (PyErr_Occurred()) SWIG_fail;
29996 }
29997 {
29998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29999 }
30000 return resultobj;
30001 fail:
30002 return NULL;
30003 }
30004
30005
30006 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
30007 PyObject *resultobj;
30008 wxClipboard *arg1 = (wxClipboard *) 0 ;
30009 wxDataFormat *arg2 = 0 ;
30010 bool result;
30011 PyObject * obj0 = 0 ;
30012 PyObject * obj1 = 0 ;
30013 char *kwnames[] = {
30014 (char *) "self",(char *) "format", NULL
30015 };
30016
30017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
30018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30019 if (SWIG_arg_fail(1)) SWIG_fail;
30020 {
30021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
30022 if (SWIG_arg_fail(2)) SWIG_fail;
30023 if (arg2 == NULL) {
30024 SWIG_null_ref("wxDataFormat");
30025 }
30026 if (SWIG_arg_fail(2)) SWIG_fail;
30027 }
30028 {
30029 PyThreadState* __tstate = wxPyBeginAllowThreads();
30030 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
30031
30032 wxPyEndAllowThreads(__tstate);
30033 if (PyErr_Occurred()) SWIG_fail;
30034 }
30035 {
30036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30037 }
30038 return resultobj;
30039 fail:
30040 return NULL;
30041 }
30042
30043
30044 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30045 PyObject *resultobj;
30046 wxClipboard *arg1 = (wxClipboard *) 0 ;
30047 wxDataObject *arg2 = 0 ;
30048 bool result;
30049 PyObject * obj0 = 0 ;
30050 PyObject * obj1 = 0 ;
30051 char *kwnames[] = {
30052 (char *) "self",(char *) "data", NULL
30053 };
30054
30055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30057 if (SWIG_arg_fail(1)) SWIG_fail;
30058 {
30059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30060 if (SWIG_arg_fail(2)) SWIG_fail;
30061 if (arg2 == NULL) {
30062 SWIG_null_ref("wxDataObject");
30063 }
30064 if (SWIG_arg_fail(2)) SWIG_fail;
30065 }
30066 {
30067 PyThreadState* __tstate = wxPyBeginAllowThreads();
30068 result = (bool)(arg1)->GetData(*arg2);
30069
30070 wxPyEndAllowThreads(__tstate);
30071 if (PyErr_Occurred()) SWIG_fail;
30072 }
30073 {
30074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30075 }
30076 return resultobj;
30077 fail:
30078 return NULL;
30079 }
30080
30081
30082 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30083 PyObject *resultobj;
30084 wxClipboard *arg1 = (wxClipboard *) 0 ;
30085 PyObject * obj0 = 0 ;
30086 char *kwnames[] = {
30087 (char *) "self", NULL
30088 };
30089
30090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30092 if (SWIG_arg_fail(1)) SWIG_fail;
30093 {
30094 PyThreadState* __tstate = wxPyBeginAllowThreads();
30095 (arg1)->Clear();
30096
30097 wxPyEndAllowThreads(__tstate);
30098 if (PyErr_Occurred()) SWIG_fail;
30099 }
30100 Py_INCREF(Py_None); resultobj = Py_None;
30101 return resultobj;
30102 fail:
30103 return NULL;
30104 }
30105
30106
30107 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30108 PyObject *resultobj;
30109 wxClipboard *arg1 = (wxClipboard *) 0 ;
30110 bool result;
30111 PyObject * obj0 = 0 ;
30112 char *kwnames[] = {
30113 (char *) "self", NULL
30114 };
30115
30116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30118 if (SWIG_arg_fail(1)) SWIG_fail;
30119 {
30120 PyThreadState* __tstate = wxPyBeginAllowThreads();
30121 result = (bool)(arg1)->Flush();
30122
30123 wxPyEndAllowThreads(__tstate);
30124 if (PyErr_Occurred()) SWIG_fail;
30125 }
30126 {
30127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30128 }
30129 return resultobj;
30130 fail:
30131 return NULL;
30132 }
30133
30134
30135 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30136 PyObject *resultobj;
30137 wxClipboard *arg1 = (wxClipboard *) 0 ;
30138 bool arg2 = (bool) true ;
30139 PyObject * obj0 = 0 ;
30140 PyObject * obj1 = 0 ;
30141 char *kwnames[] = {
30142 (char *) "self",(char *) "primary", NULL
30143 };
30144
30145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30147 if (SWIG_arg_fail(1)) SWIG_fail;
30148 if (obj1) {
30149 {
30150 arg2 = (bool)(SWIG_As_bool(obj1));
30151 if (SWIG_arg_fail(2)) SWIG_fail;
30152 }
30153 }
30154 {
30155 PyThreadState* __tstate = wxPyBeginAllowThreads();
30156 (arg1)->UsePrimarySelection(arg2);
30157
30158 wxPyEndAllowThreads(__tstate);
30159 if (PyErr_Occurred()) SWIG_fail;
30160 }
30161 Py_INCREF(Py_None); resultobj = Py_None;
30162 return resultobj;
30163 fail:
30164 return NULL;
30165 }
30166
30167
30168 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30169 PyObject *resultobj;
30170 wxClipboard *result;
30171 char *kwnames[] = {
30172 NULL
30173 };
30174
30175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30176 {
30177 PyThreadState* __tstate = wxPyBeginAllowThreads();
30178 result = (wxClipboard *)wxClipboard::Get();
30179
30180 wxPyEndAllowThreads(__tstate);
30181 if (PyErr_Occurred()) SWIG_fail;
30182 }
30183 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30184 return resultobj;
30185 fail:
30186 return NULL;
30187 }
30188
30189
30190 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30191 PyObject *obj;
30192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30193 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30194 Py_INCREF(obj);
30195 return Py_BuildValue((char *)"");
30196 }
30197 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30198 PyObject *resultobj;
30199 wxClipboard *arg1 = (wxClipboard *) NULL ;
30200 wxClipboardLocker *result;
30201 PyObject * obj0 = 0 ;
30202 char *kwnames[] = {
30203 (char *) "clipboard", NULL
30204 };
30205
30206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30207 if (obj0) {
30208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30209 if (SWIG_arg_fail(1)) SWIG_fail;
30210 }
30211 {
30212 PyThreadState* __tstate = wxPyBeginAllowThreads();
30213 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30214
30215 wxPyEndAllowThreads(__tstate);
30216 if (PyErr_Occurred()) SWIG_fail;
30217 }
30218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30219 return resultobj;
30220 fail:
30221 return NULL;
30222 }
30223
30224
30225 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30226 PyObject *resultobj;
30227 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30228 PyObject * obj0 = 0 ;
30229 char *kwnames[] = {
30230 (char *) "self", NULL
30231 };
30232
30233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30235 if (SWIG_arg_fail(1)) SWIG_fail;
30236 {
30237 PyThreadState* __tstate = wxPyBeginAllowThreads();
30238 delete arg1;
30239
30240 wxPyEndAllowThreads(__tstate);
30241 if (PyErr_Occurred()) SWIG_fail;
30242 }
30243 Py_INCREF(Py_None); resultobj = Py_None;
30244 return resultobj;
30245 fail:
30246 return NULL;
30247 }
30248
30249
30250 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30251 PyObject *resultobj;
30252 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30253 bool result;
30254 PyObject * obj0 = 0 ;
30255 char *kwnames[] = {
30256 (char *) "self", NULL
30257 };
30258
30259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30261 if (SWIG_arg_fail(1)) SWIG_fail;
30262 {
30263 PyThreadState* __tstate = wxPyBeginAllowThreads();
30264 result = (bool)wxClipboardLocker___nonzero__(arg1);
30265
30266 wxPyEndAllowThreads(__tstate);
30267 if (PyErr_Occurred()) SWIG_fail;
30268 }
30269 {
30270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30271 }
30272 return resultobj;
30273 fail:
30274 return NULL;
30275 }
30276
30277
30278 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30279 PyObject *obj;
30280 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30281 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30282 Py_INCREF(obj);
30283 return Py_BuildValue((char *)"");
30284 }
30285 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30286 PyObject *resultobj;
30287 int arg1 = (int) 0 ;
30288 int arg2 = (int) 0 ;
30289 int arg3 = (int) 0 ;
30290 int arg4 = (int) 0 ;
30291 wxVideoMode *result;
30292 PyObject * obj0 = 0 ;
30293 PyObject * obj1 = 0 ;
30294 PyObject * obj2 = 0 ;
30295 PyObject * obj3 = 0 ;
30296 char *kwnames[] = {
30297 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30298 };
30299
30300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30301 if (obj0) {
30302 {
30303 arg1 = (int)(SWIG_As_int(obj0));
30304 if (SWIG_arg_fail(1)) SWIG_fail;
30305 }
30306 }
30307 if (obj1) {
30308 {
30309 arg2 = (int)(SWIG_As_int(obj1));
30310 if (SWIG_arg_fail(2)) SWIG_fail;
30311 }
30312 }
30313 if (obj2) {
30314 {
30315 arg3 = (int)(SWIG_As_int(obj2));
30316 if (SWIG_arg_fail(3)) SWIG_fail;
30317 }
30318 }
30319 if (obj3) {
30320 {
30321 arg4 = (int)(SWIG_As_int(obj3));
30322 if (SWIG_arg_fail(4)) SWIG_fail;
30323 }
30324 }
30325 {
30326 PyThreadState* __tstate = wxPyBeginAllowThreads();
30327 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30328
30329 wxPyEndAllowThreads(__tstate);
30330 if (PyErr_Occurred()) SWIG_fail;
30331 }
30332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30333 return resultobj;
30334 fail:
30335 return NULL;
30336 }
30337
30338
30339 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30340 PyObject *resultobj;
30341 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30342 PyObject * obj0 = 0 ;
30343 char *kwnames[] = {
30344 (char *) "self", NULL
30345 };
30346
30347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30349 if (SWIG_arg_fail(1)) SWIG_fail;
30350 {
30351 PyThreadState* __tstate = wxPyBeginAllowThreads();
30352 delete arg1;
30353
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 Py_INCREF(Py_None); resultobj = Py_None;
30358 return resultobj;
30359 fail:
30360 return NULL;
30361 }
30362
30363
30364 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30365 PyObject *resultobj;
30366 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30367 wxVideoMode *arg2 = 0 ;
30368 bool result;
30369 PyObject * obj0 = 0 ;
30370 PyObject * obj1 = 0 ;
30371 char *kwnames[] = {
30372 (char *) "self",(char *) "other", NULL
30373 };
30374
30375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30377 if (SWIG_arg_fail(1)) SWIG_fail;
30378 {
30379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30380 if (SWIG_arg_fail(2)) SWIG_fail;
30381 if (arg2 == NULL) {
30382 SWIG_null_ref("wxVideoMode");
30383 }
30384 if (SWIG_arg_fail(2)) SWIG_fail;
30385 }
30386 {
30387 PyThreadState* __tstate = wxPyBeginAllowThreads();
30388 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30389
30390 wxPyEndAllowThreads(__tstate);
30391 if (PyErr_Occurred()) SWIG_fail;
30392 }
30393 {
30394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30395 }
30396 return resultobj;
30397 fail:
30398 return NULL;
30399 }
30400
30401
30402 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30403 PyObject *resultobj;
30404 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30405 int result;
30406 PyObject * obj0 = 0 ;
30407 char *kwnames[] = {
30408 (char *) "self", NULL
30409 };
30410
30411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30413 if (SWIG_arg_fail(1)) SWIG_fail;
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30417
30418 wxPyEndAllowThreads(__tstate);
30419 if (PyErr_Occurred()) SWIG_fail;
30420 }
30421 {
30422 resultobj = SWIG_From_int((int)(result));
30423 }
30424 return resultobj;
30425 fail:
30426 return NULL;
30427 }
30428
30429
30430 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30431 PyObject *resultobj;
30432 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30433 int result;
30434 PyObject * obj0 = 0 ;
30435 char *kwnames[] = {
30436 (char *) "self", NULL
30437 };
30438
30439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30441 if (SWIG_arg_fail(1)) SWIG_fail;
30442 {
30443 PyThreadState* __tstate = wxPyBeginAllowThreads();
30444 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30445
30446 wxPyEndAllowThreads(__tstate);
30447 if (PyErr_Occurred()) SWIG_fail;
30448 }
30449 {
30450 resultobj = SWIG_From_int((int)(result));
30451 }
30452 return resultobj;
30453 fail:
30454 return NULL;
30455 }
30456
30457
30458 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30459 PyObject *resultobj;
30460 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30461 int result;
30462 PyObject * obj0 = 0 ;
30463 char *kwnames[] = {
30464 (char *) "self", NULL
30465 };
30466
30467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30469 if (SWIG_arg_fail(1)) SWIG_fail;
30470 {
30471 PyThreadState* __tstate = wxPyBeginAllowThreads();
30472 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30473
30474 wxPyEndAllowThreads(__tstate);
30475 if (PyErr_Occurred()) SWIG_fail;
30476 }
30477 {
30478 resultobj = SWIG_From_int((int)(result));
30479 }
30480 return resultobj;
30481 fail:
30482 return NULL;
30483 }
30484
30485
30486 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30487 PyObject *resultobj;
30488 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30489 bool result;
30490 PyObject * obj0 = 0 ;
30491 char *kwnames[] = {
30492 (char *) "self", NULL
30493 };
30494
30495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30497 if (SWIG_arg_fail(1)) SWIG_fail;
30498 {
30499 PyThreadState* __tstate = wxPyBeginAllowThreads();
30500 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30501
30502 wxPyEndAllowThreads(__tstate);
30503 if (PyErr_Occurred()) SWIG_fail;
30504 }
30505 {
30506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30507 }
30508 return resultobj;
30509 fail:
30510 return NULL;
30511 }
30512
30513
30514 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30515 PyObject *resultobj;
30516 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30517 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30518 bool result;
30519 PyObject * obj0 = 0 ;
30520 PyObject * obj1 = 0 ;
30521 char *kwnames[] = {
30522 (char *) "self",(char *) "other", NULL
30523 };
30524
30525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30527 if (SWIG_arg_fail(1)) SWIG_fail;
30528 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30529 if (SWIG_arg_fail(2)) SWIG_fail;
30530 {
30531 PyThreadState* __tstate = wxPyBeginAllowThreads();
30532 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30533
30534 wxPyEndAllowThreads(__tstate);
30535 if (PyErr_Occurred()) SWIG_fail;
30536 }
30537 {
30538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30539 }
30540 return resultobj;
30541 fail:
30542 return NULL;
30543 }
30544
30545
30546 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30547 PyObject *resultobj;
30548 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30549 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30550 bool result;
30551 PyObject * obj0 = 0 ;
30552 PyObject * obj1 = 0 ;
30553 char *kwnames[] = {
30554 (char *) "self",(char *) "other", NULL
30555 };
30556
30557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30559 if (SWIG_arg_fail(1)) SWIG_fail;
30560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30561 if (SWIG_arg_fail(2)) SWIG_fail;
30562 {
30563 PyThreadState* __tstate = wxPyBeginAllowThreads();
30564 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30565
30566 wxPyEndAllowThreads(__tstate);
30567 if (PyErr_Occurred()) SWIG_fail;
30568 }
30569 {
30570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30571 }
30572 return resultobj;
30573 fail:
30574 return NULL;
30575 }
30576
30577
30578 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30579 PyObject *resultobj;
30580 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30581 int arg2 ;
30582 PyObject * obj0 = 0 ;
30583 PyObject * obj1 = 0 ;
30584 char *kwnames[] = {
30585 (char *) "self",(char *) "w", NULL
30586 };
30587
30588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30590 if (SWIG_arg_fail(1)) SWIG_fail;
30591 {
30592 arg2 = (int)(SWIG_As_int(obj1));
30593 if (SWIG_arg_fail(2)) SWIG_fail;
30594 }
30595 if (arg1) (arg1)->w = arg2;
30596
30597 Py_INCREF(Py_None); resultobj = Py_None;
30598 return resultobj;
30599 fail:
30600 return NULL;
30601 }
30602
30603
30604 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30605 PyObject *resultobj;
30606 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30607 int result;
30608 PyObject * obj0 = 0 ;
30609 char *kwnames[] = {
30610 (char *) "self", NULL
30611 };
30612
30613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30615 if (SWIG_arg_fail(1)) SWIG_fail;
30616 result = (int) ((arg1)->w);
30617
30618 {
30619 resultobj = SWIG_From_int((int)(result));
30620 }
30621 return resultobj;
30622 fail:
30623 return NULL;
30624 }
30625
30626
30627 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30628 PyObject *resultobj;
30629 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30630 int arg2 ;
30631 PyObject * obj0 = 0 ;
30632 PyObject * obj1 = 0 ;
30633 char *kwnames[] = {
30634 (char *) "self",(char *) "h", NULL
30635 };
30636
30637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30639 if (SWIG_arg_fail(1)) SWIG_fail;
30640 {
30641 arg2 = (int)(SWIG_As_int(obj1));
30642 if (SWIG_arg_fail(2)) SWIG_fail;
30643 }
30644 if (arg1) (arg1)->h = arg2;
30645
30646 Py_INCREF(Py_None); resultobj = Py_None;
30647 return resultobj;
30648 fail:
30649 return NULL;
30650 }
30651
30652
30653 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30654 PyObject *resultobj;
30655 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30656 int result;
30657 PyObject * obj0 = 0 ;
30658 char *kwnames[] = {
30659 (char *) "self", NULL
30660 };
30661
30662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30664 if (SWIG_arg_fail(1)) SWIG_fail;
30665 result = (int) ((arg1)->h);
30666
30667 {
30668 resultobj = SWIG_From_int((int)(result));
30669 }
30670 return resultobj;
30671 fail:
30672 return NULL;
30673 }
30674
30675
30676 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30677 PyObject *resultobj;
30678 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30679 int arg2 ;
30680 PyObject * obj0 = 0 ;
30681 PyObject * obj1 = 0 ;
30682 char *kwnames[] = {
30683 (char *) "self",(char *) "bpp", NULL
30684 };
30685
30686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30688 if (SWIG_arg_fail(1)) SWIG_fail;
30689 {
30690 arg2 = (int)(SWIG_As_int(obj1));
30691 if (SWIG_arg_fail(2)) SWIG_fail;
30692 }
30693 if (arg1) (arg1)->bpp = arg2;
30694
30695 Py_INCREF(Py_None); resultobj = Py_None;
30696 return resultobj;
30697 fail:
30698 return NULL;
30699 }
30700
30701
30702 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30703 PyObject *resultobj;
30704 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30705 int result;
30706 PyObject * obj0 = 0 ;
30707 char *kwnames[] = {
30708 (char *) "self", NULL
30709 };
30710
30711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30713 if (SWIG_arg_fail(1)) SWIG_fail;
30714 result = (int) ((arg1)->bpp);
30715
30716 {
30717 resultobj = SWIG_From_int((int)(result));
30718 }
30719 return resultobj;
30720 fail:
30721 return NULL;
30722 }
30723
30724
30725 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30726 PyObject *resultobj;
30727 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30728 int arg2 ;
30729 PyObject * obj0 = 0 ;
30730 PyObject * obj1 = 0 ;
30731 char *kwnames[] = {
30732 (char *) "self",(char *) "refresh", NULL
30733 };
30734
30735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30737 if (SWIG_arg_fail(1)) SWIG_fail;
30738 {
30739 arg2 = (int)(SWIG_As_int(obj1));
30740 if (SWIG_arg_fail(2)) SWIG_fail;
30741 }
30742 if (arg1) (arg1)->refresh = arg2;
30743
30744 Py_INCREF(Py_None); resultobj = Py_None;
30745 return resultobj;
30746 fail:
30747 return NULL;
30748 }
30749
30750
30751 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30752 PyObject *resultobj;
30753 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30754 int result;
30755 PyObject * obj0 = 0 ;
30756 char *kwnames[] = {
30757 (char *) "self", NULL
30758 };
30759
30760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30762 if (SWIG_arg_fail(1)) SWIG_fail;
30763 result = (int) ((arg1)->refresh);
30764
30765 {
30766 resultobj = SWIG_From_int((int)(result));
30767 }
30768 return resultobj;
30769 fail:
30770 return NULL;
30771 }
30772
30773
30774 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30775 PyObject *obj;
30776 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30777 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30778 Py_INCREF(obj);
30779 return Py_BuildValue((char *)"");
30780 }
30781 static int _wrap_DefaultVideoMode_set(PyObject *) {
30782 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30783 return 1;
30784 }
30785
30786
30787 static PyObject *_wrap_DefaultVideoMode_get(void) {
30788 PyObject *pyobj;
30789
30790 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30791 return pyobj;
30792 }
30793
30794
30795 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30796 PyObject *resultobj;
30797 size_t arg1 = (size_t) 0 ;
30798 wxDisplay *result;
30799 PyObject * obj0 = 0 ;
30800 char *kwnames[] = {
30801 (char *) "index", NULL
30802 };
30803
30804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30805 if (obj0) {
30806 {
30807 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30808 if (SWIG_arg_fail(1)) SWIG_fail;
30809 }
30810 }
30811 {
30812 PyThreadState* __tstate = wxPyBeginAllowThreads();
30813 result = (wxDisplay *)new wxDisplay(arg1);
30814
30815 wxPyEndAllowThreads(__tstate);
30816 if (PyErr_Occurred()) SWIG_fail;
30817 }
30818 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30819 return resultobj;
30820 fail:
30821 return NULL;
30822 }
30823
30824
30825 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30826 PyObject *resultobj;
30827 wxDisplay *arg1 = (wxDisplay *) 0 ;
30828 PyObject * obj0 = 0 ;
30829 char *kwnames[] = {
30830 (char *) "self", NULL
30831 };
30832
30833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30835 if (SWIG_arg_fail(1)) SWIG_fail;
30836 {
30837 PyThreadState* __tstate = wxPyBeginAllowThreads();
30838 delete arg1;
30839
30840 wxPyEndAllowThreads(__tstate);
30841 if (PyErr_Occurred()) SWIG_fail;
30842 }
30843 Py_INCREF(Py_None); resultobj = Py_None;
30844 return resultobj;
30845 fail:
30846 return NULL;
30847 }
30848
30849
30850 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30851 PyObject *resultobj;
30852 size_t result;
30853 char *kwnames[] = {
30854 NULL
30855 };
30856
30857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30858 {
30859 PyThreadState* __tstate = wxPyBeginAllowThreads();
30860 result = (size_t)wxDisplay::GetCount();
30861
30862 wxPyEndAllowThreads(__tstate);
30863 if (PyErr_Occurred()) SWIG_fail;
30864 }
30865 {
30866 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30867 }
30868 return resultobj;
30869 fail:
30870 return NULL;
30871 }
30872
30873
30874 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30875 PyObject *resultobj;
30876 wxPoint *arg1 = 0 ;
30877 int result;
30878 wxPoint temp1 ;
30879 PyObject * obj0 = 0 ;
30880 char *kwnames[] = {
30881 (char *) "pt", NULL
30882 };
30883
30884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30885 {
30886 arg1 = &temp1;
30887 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30888 }
30889 {
30890 PyThreadState* __tstate = wxPyBeginAllowThreads();
30891 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30892
30893 wxPyEndAllowThreads(__tstate);
30894 if (PyErr_Occurred()) SWIG_fail;
30895 }
30896 {
30897 resultobj = SWIG_From_int((int)(result));
30898 }
30899 return resultobj;
30900 fail:
30901 return NULL;
30902 }
30903
30904
30905 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30906 PyObject *resultobj;
30907 wxWindow *arg1 = (wxWindow *) 0 ;
30908 int result;
30909 PyObject * obj0 = 0 ;
30910 char *kwnames[] = {
30911 (char *) "window", NULL
30912 };
30913
30914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30916 if (SWIG_arg_fail(1)) SWIG_fail;
30917 {
30918 PyThreadState* __tstate = wxPyBeginAllowThreads();
30919 result = (int)Display_GetFromWindow(arg1);
30920
30921 wxPyEndAllowThreads(__tstate);
30922 if (PyErr_Occurred()) SWIG_fail;
30923 }
30924 {
30925 resultobj = SWIG_From_int((int)(result));
30926 }
30927 return resultobj;
30928 fail:
30929 return NULL;
30930 }
30931
30932
30933 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30934 PyObject *resultobj;
30935 wxDisplay *arg1 = (wxDisplay *) 0 ;
30936 bool result;
30937 PyObject * obj0 = 0 ;
30938 char *kwnames[] = {
30939 (char *) "self", NULL
30940 };
30941
30942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30944 if (SWIG_arg_fail(1)) SWIG_fail;
30945 {
30946 PyThreadState* __tstate = wxPyBeginAllowThreads();
30947 result = (bool)((wxDisplay const *)arg1)->IsOk();
30948
30949 wxPyEndAllowThreads(__tstate);
30950 if (PyErr_Occurred()) SWIG_fail;
30951 }
30952 {
30953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30954 }
30955 return resultobj;
30956 fail:
30957 return NULL;
30958 }
30959
30960
30961 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30962 PyObject *resultobj;
30963 wxDisplay *arg1 = (wxDisplay *) 0 ;
30964 wxRect result;
30965 PyObject * obj0 = 0 ;
30966 char *kwnames[] = {
30967 (char *) "self", NULL
30968 };
30969
30970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30972 if (SWIG_arg_fail(1)) SWIG_fail;
30973 {
30974 PyThreadState* __tstate = wxPyBeginAllowThreads();
30975 result = ((wxDisplay const *)arg1)->GetGeometry();
30976
30977 wxPyEndAllowThreads(__tstate);
30978 if (PyErr_Occurred()) SWIG_fail;
30979 }
30980 {
30981 wxRect * resultptr;
30982 resultptr = new wxRect((wxRect &)(result));
30983 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30984 }
30985 return resultobj;
30986 fail:
30987 return NULL;
30988 }
30989
30990
30991 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30992 PyObject *resultobj;
30993 wxDisplay *arg1 = (wxDisplay *) 0 ;
30994 wxString result;
30995 PyObject * obj0 = 0 ;
30996 char *kwnames[] = {
30997 (char *) "self", NULL
30998 };
30999
31000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
31001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31002 if (SWIG_arg_fail(1)) SWIG_fail;
31003 {
31004 PyThreadState* __tstate = wxPyBeginAllowThreads();
31005 result = ((wxDisplay const *)arg1)->GetName();
31006
31007 wxPyEndAllowThreads(__tstate);
31008 if (PyErr_Occurred()) SWIG_fail;
31009 }
31010 {
31011 #if wxUSE_UNICODE
31012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31013 #else
31014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31015 #endif
31016 }
31017 return resultobj;
31018 fail:
31019 return NULL;
31020 }
31021
31022
31023 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
31024 PyObject *resultobj;
31025 wxDisplay *arg1 = (wxDisplay *) 0 ;
31026 bool result;
31027 PyObject * obj0 = 0 ;
31028 char *kwnames[] = {
31029 (char *) "self", NULL
31030 };
31031
31032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
31033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31034 if (SWIG_arg_fail(1)) SWIG_fail;
31035 {
31036 PyThreadState* __tstate = wxPyBeginAllowThreads();
31037 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31038
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 {
31043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31044 }
31045 return resultobj;
31046 fail:
31047 return NULL;
31048 }
31049
31050
31051 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31052 PyObject *resultobj;
31053 wxDisplay *arg1 = (wxDisplay *) 0 ;
31054 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31055 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31056 PyObject *result;
31057 PyObject * obj0 = 0 ;
31058 PyObject * obj1 = 0 ;
31059 char *kwnames[] = {
31060 (char *) "self",(char *) "mode", NULL
31061 };
31062
31063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31065 if (SWIG_arg_fail(1)) SWIG_fail;
31066 if (obj1) {
31067 {
31068 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31069 if (SWIG_arg_fail(2)) SWIG_fail;
31070 if (arg2 == NULL) {
31071 SWIG_null_ref("wxVideoMode");
31072 }
31073 if (SWIG_arg_fail(2)) SWIG_fail;
31074 }
31075 }
31076 {
31077 PyThreadState* __tstate = wxPyBeginAllowThreads();
31078 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31079
31080 wxPyEndAllowThreads(__tstate);
31081 if (PyErr_Occurred()) SWIG_fail;
31082 }
31083 resultobj = result;
31084 return resultobj;
31085 fail:
31086 return NULL;
31087 }
31088
31089
31090 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31091 PyObject *resultobj;
31092 wxDisplay *arg1 = (wxDisplay *) 0 ;
31093 wxVideoMode result;
31094 PyObject * obj0 = 0 ;
31095 char *kwnames[] = {
31096 (char *) "self", NULL
31097 };
31098
31099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31101 if (SWIG_arg_fail(1)) SWIG_fail;
31102 {
31103 PyThreadState* __tstate = wxPyBeginAllowThreads();
31104 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31105
31106 wxPyEndAllowThreads(__tstate);
31107 if (PyErr_Occurred()) SWIG_fail;
31108 }
31109 {
31110 wxVideoMode * resultptr;
31111 resultptr = new wxVideoMode((wxVideoMode &)(result));
31112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31113 }
31114 return resultobj;
31115 fail:
31116 return NULL;
31117 }
31118
31119
31120 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31121 PyObject *resultobj;
31122 wxDisplay *arg1 = (wxDisplay *) 0 ;
31123 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31124 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31125 bool result;
31126 PyObject * obj0 = 0 ;
31127 PyObject * obj1 = 0 ;
31128 char *kwnames[] = {
31129 (char *) "self",(char *) "mode", NULL
31130 };
31131
31132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31134 if (SWIG_arg_fail(1)) SWIG_fail;
31135 if (obj1) {
31136 {
31137 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31138 if (SWIG_arg_fail(2)) SWIG_fail;
31139 if (arg2 == NULL) {
31140 SWIG_null_ref("wxVideoMode");
31141 }
31142 if (SWIG_arg_fail(2)) SWIG_fail;
31143 }
31144 }
31145 {
31146 PyThreadState* __tstate = wxPyBeginAllowThreads();
31147 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31148
31149 wxPyEndAllowThreads(__tstate);
31150 if (PyErr_Occurred()) SWIG_fail;
31151 }
31152 {
31153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31154 }
31155 return resultobj;
31156 fail:
31157 return NULL;
31158 }
31159
31160
31161 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31162 PyObject *resultobj;
31163 wxDisplay *arg1 = (wxDisplay *) 0 ;
31164 PyObject * obj0 = 0 ;
31165 char *kwnames[] = {
31166 (char *) "self", NULL
31167 };
31168
31169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31171 if (SWIG_arg_fail(1)) SWIG_fail;
31172 {
31173 PyThreadState* __tstate = wxPyBeginAllowThreads();
31174 (arg1)->ResetMode();
31175
31176 wxPyEndAllowThreads(__tstate);
31177 if (PyErr_Occurred()) SWIG_fail;
31178 }
31179 Py_INCREF(Py_None); resultobj = Py_None;
31180 return resultobj;
31181 fail:
31182 return NULL;
31183 }
31184
31185
31186 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31187 PyObject *obj;
31188 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31189 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31190 Py_INCREF(obj);
31191 return Py_BuildValue((char *)"");
31192 }
31193 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31194 PyObject *resultobj;
31195 wxStandardPaths *result;
31196 char *kwnames[] = {
31197 NULL
31198 };
31199
31200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31201 {
31202 PyThreadState* __tstate = wxPyBeginAllowThreads();
31203 result = (wxStandardPaths *)StandardPaths_Get();
31204
31205 wxPyEndAllowThreads(__tstate);
31206 if (PyErr_Occurred()) SWIG_fail;
31207 }
31208 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31209 return resultobj;
31210 fail:
31211 return NULL;
31212 }
31213
31214
31215 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31216 PyObject *resultobj;
31217 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31218 wxString result;
31219 PyObject * obj0 = 0 ;
31220 char *kwnames[] = {
31221 (char *) "self", NULL
31222 };
31223
31224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31226 if (SWIG_arg_fail(1)) SWIG_fail;
31227 {
31228 PyThreadState* __tstate = wxPyBeginAllowThreads();
31229 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31230
31231 wxPyEndAllowThreads(__tstate);
31232 if (PyErr_Occurred()) SWIG_fail;
31233 }
31234 {
31235 #if wxUSE_UNICODE
31236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31237 #else
31238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31239 #endif
31240 }
31241 return resultobj;
31242 fail:
31243 return NULL;
31244 }
31245
31246
31247 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31248 PyObject *resultobj;
31249 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31250 wxString result;
31251 PyObject * obj0 = 0 ;
31252 char *kwnames[] = {
31253 (char *) "self", NULL
31254 };
31255
31256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31258 if (SWIG_arg_fail(1)) SWIG_fail;
31259 {
31260 PyThreadState* __tstate = wxPyBeginAllowThreads();
31261 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31262
31263 wxPyEndAllowThreads(__tstate);
31264 if (PyErr_Occurred()) SWIG_fail;
31265 }
31266 {
31267 #if wxUSE_UNICODE
31268 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31269 #else
31270 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31271 #endif
31272 }
31273 return resultobj;
31274 fail:
31275 return NULL;
31276 }
31277
31278
31279 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31280 PyObject *resultobj;
31281 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31282 wxString result;
31283 PyObject * obj0 = 0 ;
31284 char *kwnames[] = {
31285 (char *) "self", NULL
31286 };
31287
31288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31290 if (SWIG_arg_fail(1)) SWIG_fail;
31291 {
31292 PyThreadState* __tstate = wxPyBeginAllowThreads();
31293 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31294
31295 wxPyEndAllowThreads(__tstate);
31296 if (PyErr_Occurred()) SWIG_fail;
31297 }
31298 {
31299 #if wxUSE_UNICODE
31300 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31301 #else
31302 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31303 #endif
31304 }
31305 return resultobj;
31306 fail:
31307 return NULL;
31308 }
31309
31310
31311 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31312 PyObject *resultobj;
31313 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31314 wxString result;
31315 PyObject * obj0 = 0 ;
31316 char *kwnames[] = {
31317 (char *) "self", NULL
31318 };
31319
31320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31322 if (SWIG_arg_fail(1)) SWIG_fail;
31323 {
31324 PyThreadState* __tstate = wxPyBeginAllowThreads();
31325 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31326
31327 wxPyEndAllowThreads(__tstate);
31328 if (PyErr_Occurred()) SWIG_fail;
31329 }
31330 {
31331 #if wxUSE_UNICODE
31332 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31333 #else
31334 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31335 #endif
31336 }
31337 return resultobj;
31338 fail:
31339 return NULL;
31340 }
31341
31342
31343 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31344 PyObject *resultobj;
31345 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31346 wxString result;
31347 PyObject * obj0 = 0 ;
31348 char *kwnames[] = {
31349 (char *) "self", NULL
31350 };
31351
31352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31354 if (SWIG_arg_fail(1)) SWIG_fail;
31355 {
31356 PyThreadState* __tstate = wxPyBeginAllowThreads();
31357 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31358
31359 wxPyEndAllowThreads(__tstate);
31360 if (PyErr_Occurred()) SWIG_fail;
31361 }
31362 {
31363 #if wxUSE_UNICODE
31364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31365 #else
31366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31367 #endif
31368 }
31369 return resultobj;
31370 fail:
31371 return NULL;
31372 }
31373
31374
31375 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31376 PyObject *resultobj;
31377 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31378 wxString result;
31379 PyObject * obj0 = 0 ;
31380 char *kwnames[] = {
31381 (char *) "self", NULL
31382 };
31383
31384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31386 if (SWIG_arg_fail(1)) SWIG_fail;
31387 {
31388 PyThreadState* __tstate = wxPyBeginAllowThreads();
31389 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31390
31391 wxPyEndAllowThreads(__tstate);
31392 if (PyErr_Occurred()) SWIG_fail;
31393 }
31394 {
31395 #if wxUSE_UNICODE
31396 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31397 #else
31398 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31399 #endif
31400 }
31401 return resultobj;
31402 fail:
31403 return NULL;
31404 }
31405
31406
31407 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31408 PyObject *resultobj;
31409 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31410 wxString result;
31411 PyObject * obj0 = 0 ;
31412 char *kwnames[] = {
31413 (char *) "self", NULL
31414 };
31415
31416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31418 if (SWIG_arg_fail(1)) SWIG_fail;
31419 {
31420 PyThreadState* __tstate = wxPyBeginAllowThreads();
31421 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31422
31423 wxPyEndAllowThreads(__tstate);
31424 if (PyErr_Occurred()) SWIG_fail;
31425 }
31426 {
31427 #if wxUSE_UNICODE
31428 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31429 #else
31430 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31431 #endif
31432 }
31433 return resultobj;
31434 fail:
31435 return NULL;
31436 }
31437
31438
31439 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31440 PyObject *resultobj;
31441 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31442 wxString *arg2 = 0 ;
31443 bool temp2 = false ;
31444 PyObject * obj0 = 0 ;
31445 PyObject * obj1 = 0 ;
31446 char *kwnames[] = {
31447 (char *) "self",(char *) "prefix", NULL
31448 };
31449
31450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31452 if (SWIG_arg_fail(1)) SWIG_fail;
31453 {
31454 arg2 = wxString_in_helper(obj1);
31455 if (arg2 == NULL) SWIG_fail;
31456 temp2 = true;
31457 }
31458 {
31459 PyThreadState* __tstate = wxPyBeginAllowThreads();
31460 (arg1)->SetInstallPrefix((wxString const &)*arg2);
31461
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 Py_INCREF(Py_None); resultobj = Py_None;
31466 {
31467 if (temp2)
31468 delete arg2;
31469 }
31470 return resultobj;
31471 fail:
31472 {
31473 if (temp2)
31474 delete arg2;
31475 }
31476 return NULL;
31477 }
31478
31479
31480 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31481 PyObject *resultobj;
31482 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31483 wxString result;
31484 PyObject * obj0 = 0 ;
31485 char *kwnames[] = {
31486 (char *) "self", NULL
31487 };
31488
31489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31491 if (SWIG_arg_fail(1)) SWIG_fail;
31492 {
31493 PyThreadState* __tstate = wxPyBeginAllowThreads();
31494 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
31495
31496 wxPyEndAllowThreads(__tstate);
31497 if (PyErr_Occurred()) SWIG_fail;
31498 }
31499 {
31500 #if wxUSE_UNICODE
31501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31502 #else
31503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31504 #endif
31505 }
31506 return resultobj;
31507 fail:
31508 return NULL;
31509 }
31510
31511
31512 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31513 PyObject *obj;
31514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31515 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31516 Py_INCREF(obj);
31517 return Py_BuildValue((char *)"");
31518 }
31519 static PyMethodDef SwigMethods[] = {
31520 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31527 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31535 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31601 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31609 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31627 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31630 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31633 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31636 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31642 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31656 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31662 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31668 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31671 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31685 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31688 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31689 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31692 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31719 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31721 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31723 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31725 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31732 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31738 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31752 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31756 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31759 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31776 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31784 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31831 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31849 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31859 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31875 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31891 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31905 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31915 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31958 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31961 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31964 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31968 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32061 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32062 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32063 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32064 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32081 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32126 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32160 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32168 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32169 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32174 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32183 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32190 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32193 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32196 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32201 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32204 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32208 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32211 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32215 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32216 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32220 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32224 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32226 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32236 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32249 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32257 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32265 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32277 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32279 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32280 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32281 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32283 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32286 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32290 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32292 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32293 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32294 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32295 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32296 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32297 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32298 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32299 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32300 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32301 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32302 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32303 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32304 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32305 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32306 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32307 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32308 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32309 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32310 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32311 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32312 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32313 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32314 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32315 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32316 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32317 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32318 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32319 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32320 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32321 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32322 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32323 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32324 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32325 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32326 { NULL, NULL, 0, NULL }
32327 };
32328
32329
32330 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32331
32332 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32333 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32334 }
32335 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32336 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32337 }
32338 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32339 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32340 }
32341 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32342 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32343 }
32344 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32345 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32346 }
32347 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32348 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32349 }
32350 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32351 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32352 }
32353 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32354 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32355 }
32356 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32357 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32358 }
32359 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32360 return (void *)((wxEvent *) ((wxPyEvent *) x));
32361 }
32362 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32363 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32364 }
32365 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32366 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32367 }
32368 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32369 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32370 }
32371 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32372 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32373 }
32374 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32375 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32376 }
32377 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32378 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32379 }
32380 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32381 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32382 }
32383 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32384 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32385 }
32386 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32387 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32388 }
32389 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32390 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32391 }
32392 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32393 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32394 }
32395 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32396 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32397 }
32398 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32399 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32400 }
32401 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32402 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32403 }
32404 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32405 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32406 }
32407 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32408 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32409 }
32410 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32411 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32412 }
32413 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32414 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32415 }
32416 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32417 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32418 }
32419 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32420 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32421 }
32422 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32423 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32424 }
32425 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32426 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32427 }
32428 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32429 return (void *)((wxEvent *) ((wxShowEvent *) x));
32430 }
32431 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32432 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32433 }
32434 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32435 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32436 }
32437 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32438 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32439 }
32440 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32441 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32442 }
32443 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32444 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32445 }
32446 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32447 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32448 }
32449 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32450 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32451 }
32452 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32453 return (void *)((wxConfigBase *) ((wxConfig *) x));
32454 }
32455 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32456 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32457 }
32458 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32459 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32460 }
32461 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32462 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32463 }
32464 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32465 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32466 }
32467 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32468 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32469 }
32470 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32471 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32472 }
32473 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32474 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32475 }
32476 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32477 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32478 }
32479 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32480 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32481 }
32482 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32483 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32484 }
32485 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32486 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32487 }
32488 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32489 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32490 }
32491 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32492 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32493 }
32494 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32495 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32496 }
32497 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32498 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32499 }
32500 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32501 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32502 }
32503 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32504 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32505 }
32506 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32507 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32508 }
32509 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32510 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32511 }
32512 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32513 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32514 }
32515 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32516 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32517 }
32518 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32519 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32520 }
32521 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32522 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32523 }
32524 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32525 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32526 }
32527 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32528 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32529 }
32530 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32531 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32532 }
32533 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32534 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32535 }
32536 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32537 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32538 }
32539 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32540 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32541 }
32542 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32543 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32544 }
32545 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32546 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32547 }
32548 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32549 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32550 }
32551 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32552 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32553 }
32554 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32555 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32556 }
32557 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32558 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32559 }
32560 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32561 return (void *)((wxObject *) ((wxSizerItem *) x));
32562 }
32563 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32564 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32565 }
32566 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32567 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32568 }
32569 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32570 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32571 }
32572 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32573 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32574 }
32575 static void *_p_wxSizerTo_p_wxObject(void *x) {
32576 return (void *)((wxObject *) ((wxSizer *) x));
32577 }
32578 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32579 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32580 }
32581 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32582 return (void *)((wxObject *) ((wxFileHistory *) x));
32583 }
32584 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32585 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32586 }
32587 static void *_p_wxEventTo_p_wxObject(void *x) {
32588 return (void *)((wxObject *) ((wxEvent *) x));
32589 }
32590 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32591 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32592 }
32593 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32594 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32595 }
32596 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32597 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32598 }
32599 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32600 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32601 }
32602 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32603 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32604 }
32605 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32606 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32607 }
32608 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32609 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32610 }
32611 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32612 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32613 }
32614 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32615 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32616 }
32617 static void *_p_wxControlTo_p_wxObject(void *x) {
32618 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32619 }
32620 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32621 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32622 }
32623 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32624 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32625 }
32626 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32627 return (void *)((wxObject *) ((wxFSFile *) x));
32628 }
32629 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32630 return (void *)((wxObject *) ((wxClipboard *) x));
32631 }
32632 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32633 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32634 }
32635 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32636 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32637 }
32638 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32639 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32640 }
32641 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32642 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32643 }
32644 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32645 return (void *)((wxObject *) ((wxToolTip *) x));
32646 }
32647 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32648 return (void *)((wxObject *) ((wxMenuItem *) x));
32649 }
32650 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32651 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32652 }
32653 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32654 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32655 }
32656 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32657 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32658 }
32659 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32660 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32661 }
32662 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32663 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32664 }
32665 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32666 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32667 }
32668 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32669 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32670 }
32671 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32672 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32673 }
32674 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32675 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32676 }
32677 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32678 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32679 }
32680 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32681 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32682 }
32683 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32684 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32685 }
32686 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32687 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32688 }
32689 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32690 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32691 }
32692 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32693 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32694 }
32695 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32696 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32697 }
32698 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32699 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32700 }
32701 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32702 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32703 }
32704 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32705 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32706 }
32707 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32708 return (void *)((wxObject *) ((wxImageHandler *) x));
32709 }
32710 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32711 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32712 }
32713 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32714 return (void *)((wxObject *) ((wxEvtHandler *) x));
32715 }
32716 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32717 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32718 }
32719 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32720 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32721 }
32722 static void *_p_wxImageTo_p_wxObject(void *x) {
32723 return (void *)((wxObject *) ((wxImage *) x));
32724 }
32725 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32726 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32727 }
32728 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32729 return (void *)((wxObject *) ((wxSystemOptions *) x));
32730 }
32731 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32732 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32733 }
32734 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32735 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32736 }
32737 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32738 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32739 }
32740 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32741 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32742 }
32743 static void *_p_wxWindowTo_p_wxObject(void *x) {
32744 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32745 }
32746 static void *_p_wxMenuTo_p_wxObject(void *x) {
32747 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32748 }
32749 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32750 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32751 }
32752 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32753 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32754 }
32755 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32756 return (void *)((wxObject *) ((wxFileSystem *) x));
32757 }
32758 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32759 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32760 }
32761 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32762 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32763 }
32764 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32765 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32766 }
32767 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32768 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32769 }
32770 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32771 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32772 }
32773 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32774 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32775 }
32776 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32777 return (void *)((wxObject *) ((wxBusyInfo *) x));
32778 }
32779 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32780 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32781 }
32782 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32783 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32784 }
32785 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32786 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32787 }
32788 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32789 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32790 }
32791 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32792 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32793 }
32794 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32795 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32796 }
32797 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32798 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32799 }
32800 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32801 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32802 }
32803 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32804 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32805 }
32806 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32807 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32808 }
32809 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32810 return (void *)((wxLog *) ((wxLogStderr *) x));
32811 }
32812 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32813 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32814 }
32815 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32816 return (void *)((wxLog *) ((wxLogWindow *) x));
32817 }
32818 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32819 return (void *)((wxLog *) ((wxLogChain *) x));
32820 }
32821 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32822 return (void *)((wxLog *) ((wxLogGui *) x));
32823 }
32824 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32825 return (void *)((wxLog *) ((wxPyLog *) x));
32826 }
32827 static void *_p_wxControlTo_p_wxWindow(void *x) {
32828 return (void *)((wxWindow *) ((wxControl *) x));
32829 }
32830 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32831 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32832 }
32833 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32834 return (void *)((wxWindow *) ((wxMenuBar *) x));
32835 }
32836 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32837 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32838 }
32839 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32840 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32841 }
32842 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}};
32843 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}};
32844 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}};
32845 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}};
32846 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}};
32847 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_wxDateEvent", _p_wxDateEventTo_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}};
32848 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}};
32849 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}};
32850 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}};
32851 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}};
32852 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}};
32853 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}};
32854 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}};
32855 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}};
32856 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}};
32857 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}};
32858 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}};
32859 static swig_type_info _swigt__p_void[] = {{"_p_void", 0, "void *", 0, 0, 0, 0},{"_p_void", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32860 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}};
32861 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}};
32862 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}};
32863 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}};
32864 static swig_type_info _swigt__p_wxDC[] = {{"_p_wxDC", 0, "wxDC *", 0, 0, 0, 0},{"_p_wxDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32865 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}};
32866 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}};
32867 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}};
32868 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}};
32869 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}};
32870 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}};
32871 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}};
32872 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}};
32873 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}};
32874 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}};
32875 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}};
32876 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}};
32877 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}};
32878 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}};
32879 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}};
32880 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}};
32881 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}};
32882 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}};
32883 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}};
32884 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}};
32885 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}};
32886 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}};
32887 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}};
32888 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}};
32889 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}};
32890 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}};
32891 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}};
32892 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}};
32893 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}};
32894 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}};
32895 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}};
32896 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}};
32897 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}};
32898 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}};
32899 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}};
32900 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}};
32901 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}};
32902 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}};
32903 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}};
32904 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}};
32905 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}};
32906 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}};
32907 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}};
32908 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}};
32909 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}};
32910 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}};
32911 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}};
32912 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}};
32913 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_wxDateEvent", _p_wxDateEventTo_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_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_wxPNGHandler", _p_wxPNGHandlerTo_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}};
32914 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}};
32915 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}};
32916 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}};
32917 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}};
32918 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}};
32919 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}};
32920 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}};
32921 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}};
32922 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}};
32923 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}};
32924 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}};
32925 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}};
32926 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}};
32927 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}};
32928 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}};
32929 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}};
32930 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}};
32931 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}};
32932 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}};
32933 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}};
32934 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}};
32935 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}};
32936 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}};
32937 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}};
32938 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}};
32939
32940 static swig_type_info *swig_types_initial[] = {
32941 _swigt__p_wxLogChain,
32942 _swigt__p_wxMutexGuiLocker,
32943 _swigt__p_wxFileHistory,
32944 _swigt__p_wxLog,
32945 _swigt__p_wxMenu,
32946 _swigt__p_wxEvent,
32947 _swigt__p_wxDateTime__TimeZone,
32948 _swigt__p_wxConfigBase,
32949 _swigt__p_wxDisplay,
32950 _swigt__p_wxFileType,
32951 _swigt__p_wxLogGui,
32952 _swigt__p_wxFont,
32953 _swigt__p_wxDataFormat,
32954 _swigt__p_wxTimerEvent,
32955 _swigt__p_wxCaret,
32956 _swigt__ptrdiff_t,
32957 _swigt__std__ptrdiff_t,
32958 _swigt__p_void,
32959 _swigt__p_int,
32960 _swigt__p_wxSize,
32961 _swigt__p_wxClipboard,
32962 _swigt__p_wxStopWatch,
32963 _swigt__p_wxDC,
32964 _swigt__p_wxClipboardLocker,
32965 _swigt__p_wxIcon,
32966 _swigt__p_wxLogStderr,
32967 _swigt__p_wxLogTextCtrl,
32968 _swigt__p_wxTextCtrl,
32969 _swigt__p_wxBusyCursor,
32970 _swigt__p_wxBitmapDataObject,
32971 _swigt__p_wxTextDataObject,
32972 _swigt__p_wxDataObject,
32973 _swigt__p_wxPyTextDataObject,
32974 _swigt__p_wxPyBitmapDataObject,
32975 _swigt__p_wxFileDataObject,
32976 _swigt__p_wxCustomDataObject,
32977 _swigt__p_wxURLDataObject,
32978 _swigt__p_wxMetafileDataObject,
32979 _swigt__p_wxSound,
32980 _swigt__p_wxTimerRunner,
32981 _swigt__p_wxLogWindow,
32982 _swigt__p_wxTimeSpan,
32983 _swigt__p_wxArrayString,
32984 _swigt__p_wxWindowDisabler,
32985 _swigt__p_form_ops_t,
32986 _swigt__p_wxToolTip,
32987 _swigt__p_wxDataObjectComposite,
32988 _swigt__p_wxSystemSettings,
32989 _swigt__p_wxFileConfig,
32990 _swigt__p_wxVideoMode,
32991 _swigt__p_wxDataObjectSimple,
32992 _swigt__p_wxPyDataObjectSimple,
32993 _swigt__p_wxDuplexMode,
32994 _swigt__p_wxEvtHandler,
32995 _swigt__p_wxRect,
32996 _swigt__p_char,
32997 _swigt__p_wxSingleInstanceChecker,
32998 _swigt__p_wxStandardPaths,
32999 _swigt__p_wxFileTypeInfo,
33000 _swigt__p_wxFrame,
33001 _swigt__p_wxTimer,
33002 _swigt__p_wxPaperSize,
33003 _swigt__p_wxMimeTypesManager,
33004 _swigt__p_wxPyArtProvider,
33005 _swigt__p_wxPyTipProvider,
33006 _swigt__p_wxTipProvider,
33007 _swigt__p_wxJoystick,
33008 _swigt__p_wxSystemOptions,
33009 _swigt__p_wxPoint,
33010 _swigt__p_wxJoystickEvent,
33011 _swigt__p_wxCursor,
33012 _swigt__p_wxObject,
33013 _swigt__p_wxOutputStream,
33014 _swigt__p_wxDateTime,
33015 _swigt__p_wxPyDropSource,
33016 _swigt__p_unsigned_long,
33017 _swigt__p_wxKillError,
33018 _swigt__p_wxWindow,
33019 _swigt__p_wxString,
33020 _swigt__p_wxPyProcess,
33021 _swigt__p_wxBitmap,
33022 _swigt__unsigned_int,
33023 _swigt__p_unsigned_int,
33024 _swigt__p_wxConfig,
33025 _swigt__p_unsigned_char,
33026 _swigt__p_wxChar,
33027 _swigt__p_wxBusyInfo,
33028 _swigt__p_wxPyDropTarget,
33029 _swigt__p_wxPyTextDropTarget,
33030 _swigt__p_wxPyFileDropTarget,
33031 _swigt__p_wxProcessEvent,
33032 _swigt__p_wxPyLog,
33033 _swigt__p_wxLogNull,
33034 _swigt__p_wxColour,
33035 _swigt__p_wxPyTimer,
33036 _swigt__p_wxConfigPathChanger,
33037 _swigt__p_wxDateSpan,
33038 0
33039 };
33040
33041
33042 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33043
33044 static swig_const_info swig_const_table[] = {
33045 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33046 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33047 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33048 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33049 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33050 {0, 0, 0, 0.0, 0, 0}};
33051
33052 #ifdef __cplusplus
33053 }
33054 #endif
33055
33056
33057 #ifdef __cplusplus
33058 extern "C" {
33059 #endif
33060
33061 /* Python-specific SWIG API */
33062 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33063 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33064 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33065
33066 /* -----------------------------------------------------------------------------
33067 * global variable support code.
33068 * ----------------------------------------------------------------------------- */
33069
33070 typedef struct swig_globalvar {
33071 char *name; /* Name of global variable */
33072 PyObject *(*get_attr)(); /* Return the current value */
33073 int (*set_attr)(PyObject *); /* Set the value */
33074 struct swig_globalvar *next;
33075 } swig_globalvar;
33076
33077 typedef struct swig_varlinkobject {
33078 PyObject_HEAD
33079 swig_globalvar *vars;
33080 } swig_varlinkobject;
33081
33082 static PyObject *
33083 swig_varlink_repr(swig_varlinkobject *v) {
33084 v = v;
33085 return PyString_FromString("<Swig global variables>");
33086 }
33087
33088 static int
33089 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33090 swig_globalvar *var;
33091 flags = flags;
33092 fprintf(fp,"Swig global variables { ");
33093 for (var = v->vars; var; var=var->next) {
33094 fprintf(fp,"%s", var->name);
33095 if (var->next) fprintf(fp,", ");
33096 }
33097 fprintf(fp," }\n");
33098 return 0;
33099 }
33100
33101 static PyObject *
33102 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33103 swig_globalvar *var = v->vars;
33104 while (var) {
33105 if (strcmp(var->name,n) == 0) {
33106 return (*var->get_attr)();
33107 }
33108 var = var->next;
33109 }
33110 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33111 return NULL;
33112 }
33113
33114 static int
33115 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33116 swig_globalvar *var = v->vars;
33117 while (var) {
33118 if (strcmp(var->name,n) == 0) {
33119 return (*var->set_attr)(p);
33120 }
33121 var = var->next;
33122 }
33123 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33124 return 1;
33125 }
33126
33127 static PyTypeObject varlinktype = {
33128 PyObject_HEAD_INIT(0)
33129 0, /* Number of items in variable part (ob_size) */
33130 (char *)"swigvarlink", /* Type name (tp_name) */
33131 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33132 0, /* Itemsize (tp_itemsize) */
33133 0, /* Deallocator (tp_dealloc) */
33134 (printfunc) swig_varlink_print, /* Print (tp_print) */
33135 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33136 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33137 0, /* tp_compare */
33138 (reprfunc) swig_varlink_repr, /* tp_repr */
33139 0, /* tp_as_number */
33140 0, /* tp_as_sequence */
33141 0, /* tp_as_mapping */
33142 0, /* tp_hash */
33143 0, /* tp_call */
33144 0, /* tp_str */
33145 0, /* tp_getattro */
33146 0, /* tp_setattro */
33147 0, /* tp_as_buffer */
33148 0, /* tp_flags */
33149 0, /* tp_doc */
33150 #if PY_VERSION_HEX >= 0x02000000
33151 0, /* tp_traverse */
33152 0, /* tp_clear */
33153 #endif
33154 #if PY_VERSION_HEX >= 0x02010000
33155 0, /* tp_richcompare */
33156 0, /* tp_weaklistoffset */
33157 #endif
33158 #if PY_VERSION_HEX >= 0x02020000
33159 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33160 #endif
33161 #if PY_VERSION_HEX >= 0x02030000
33162 0, /* tp_del */
33163 #endif
33164 #ifdef COUNT_ALLOCS
33165 0,0,0,0 /* tp_alloc -> tp_next */
33166 #endif
33167 };
33168
33169 /* Create a variable linking object for use later */
33170 static PyObject *
33171 SWIG_Python_newvarlink(void) {
33172 swig_varlinkobject *result = 0;
33173 result = PyMem_NEW(swig_varlinkobject,1);
33174 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33175 result->ob_type = &varlinktype;
33176 result->vars = 0;
33177 result->ob_refcnt = 0;
33178 Py_XINCREF((PyObject *) result);
33179 return ((PyObject*) result);
33180 }
33181
33182 static void
33183 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33184 swig_varlinkobject *v;
33185 swig_globalvar *gv;
33186 v= (swig_varlinkobject *) p;
33187 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33188 gv->name = (char *) malloc(strlen(name)+1);
33189 strcpy(gv->name,name);
33190 gv->get_attr = get_attr;
33191 gv->set_attr = set_attr;
33192 gv->next = v->vars;
33193 v->vars = gv;
33194 }
33195
33196 /* -----------------------------------------------------------------------------
33197 * constants/methods manipulation
33198 * ----------------------------------------------------------------------------- */
33199
33200 /* Install Constants */
33201 static void
33202 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33203 PyObject *obj = 0;
33204 size_t i;
33205 for (i = 0; constants[i].type; i++) {
33206 switch(constants[i].type) {
33207 case SWIG_PY_INT:
33208 obj = PyInt_FromLong(constants[i].lvalue);
33209 break;
33210 case SWIG_PY_FLOAT:
33211 obj = PyFloat_FromDouble(constants[i].dvalue);
33212 break;
33213 case SWIG_PY_STRING:
33214 if (constants[i].pvalue) {
33215 obj = PyString_FromString((char *) constants[i].pvalue);
33216 } else {
33217 Py_INCREF(Py_None);
33218 obj = Py_None;
33219 }
33220 break;
33221 case SWIG_PY_POINTER:
33222 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33223 break;
33224 case SWIG_PY_BINARY:
33225 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33226 break;
33227 default:
33228 obj = 0;
33229 break;
33230 }
33231 if (obj) {
33232 PyDict_SetItemString(d,constants[i].name,obj);
33233 Py_DECREF(obj);
33234 }
33235 }
33236 }
33237
33238 /* -----------------------------------------------------------------------------*/
33239 /* Fix SwigMethods to carry the callback ptrs when needed */
33240 /* -----------------------------------------------------------------------------*/
33241
33242 static void
33243 SWIG_Python_FixMethods(PyMethodDef *methods,
33244 swig_const_info *const_table,
33245 swig_type_info **types,
33246 swig_type_info **types_initial) {
33247 size_t i;
33248 for (i = 0; methods[i].ml_name; ++i) {
33249 char *c = methods[i].ml_doc;
33250 if (c && (c = strstr(c, "swig_ptr: "))) {
33251 int j;
33252 swig_const_info *ci = 0;
33253 char *name = c + 10;
33254 for (j = 0; const_table[j].type; j++) {
33255 if (strncmp(const_table[j].name, name,
33256 strlen(const_table[j].name)) == 0) {
33257 ci = &(const_table[j]);
33258 break;
33259 }
33260 }
33261 if (ci) {
33262 size_t shift = (ci->ptype) - types;
33263 swig_type_info *ty = types_initial[shift];
33264 size_t ldoc = (c - methods[i].ml_doc);
33265 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33266 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33267 char *buff = ndoc;
33268 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33269 strncpy(buff, methods[i].ml_doc, ldoc);
33270 buff += ldoc;
33271 strncpy(buff, "swig_ptr: ", 10);
33272 buff += 10;
33273 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33274 methods[i].ml_doc = ndoc;
33275 }
33276 }
33277 }
33278 }
33279
33280 /* -----------------------------------------------------------------------------*
33281 * Initialize type list
33282 * -----------------------------------------------------------------------------*/
33283
33284 #if PY_MAJOR_VERSION < 2
33285 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33286 is copied out of Python/modsupport.c in python version 2.3.4 */
33287 static int
33288 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33289 {
33290 PyObject *dict;
33291 if (!PyModule_Check(m)) {
33292 PyErr_SetString(PyExc_TypeError,
33293 "PyModule_AddObject() needs module as first arg");
33294 return -1;
33295 }
33296 if (!o) {
33297 PyErr_SetString(PyExc_TypeError,
33298 "PyModule_AddObject() needs non-NULL value");
33299 return -1;
33300 }
33301
33302 dict = PyModule_GetDict(m);
33303 if (dict == NULL) {
33304 /* Internal error -- modules must have a dict! */
33305 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33306 PyModule_GetName(m));
33307 return -1;
33308 }
33309 if (PyDict_SetItemString(dict, name, o))
33310 return -1;
33311 Py_DECREF(o);
33312 return 0;
33313 }
33314 #endif
33315
33316 static swig_type_info **
33317 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33318 static PyMethodDef swig_empty_runtime_method_table[] = {
33319 {
33320 NULL, NULL, 0, NULL
33321 }
33322 };/* Sentinel */
33323
33324 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33325 swig_empty_runtime_method_table);
33326 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33327 if (pointer && module) {
33328 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33329 }
33330 return type_list_handle;
33331 }
33332
33333 static swig_type_info **
33334 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33335 swig_type_info **type_pointer;
33336
33337 /* first check if module already created */
33338 type_pointer = SWIG_Python_GetTypeListHandle();
33339 if (type_pointer) {
33340 return type_pointer;
33341 } else {
33342 /* create a new module and variable */
33343 return SWIG_Python_SetTypeListHandle(type_list_handle);
33344 }
33345 }
33346
33347 #ifdef __cplusplus
33348 }
33349 #endif
33350
33351 /* -----------------------------------------------------------------------------*
33352 * Partial Init method
33353 * -----------------------------------------------------------------------------*/
33354
33355 #ifdef SWIG_LINK_RUNTIME
33356 #ifdef __cplusplus
33357 extern "C"
33358 #endif
33359 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33360 #endif
33361
33362 #ifdef __cplusplus
33363 extern "C"
33364 #endif
33365 SWIGEXPORT(void) SWIG_init(void) {
33366 static PyObject *SWIG_globals = 0;
33367 static int typeinit = 0;
33368 PyObject *m, *d;
33369 int i;
33370 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33371
33372 /* Fix SwigMethods to carry the callback ptrs when needed */
33373 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33374
33375 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33376 d = PyModule_GetDict(m);
33377
33378 if (!typeinit) {
33379 #ifdef SWIG_LINK_RUNTIME
33380 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33381 #else
33382 # ifndef SWIG_STATIC_RUNTIME
33383 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33384 # endif
33385 #endif
33386 for (i = 0; swig_types_initial[i]; i++) {
33387 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33388 }
33389 typeinit = 1;
33390 }
33391 SWIG_InstallConstants(d,swig_const_table);
33392
33393 {
33394 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33395 }
33396 {
33397 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33398 }
33399 {
33400 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33401 }
33402 {
33403 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33404 }
33405 {
33406 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33407 }
33408 {
33409 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33410 }
33411 {
33412 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33413 }
33414 {
33415 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33416 }
33417 {
33418 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33419 }
33420 {
33421 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33422 }
33423 {
33424 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33425 }
33426 {
33427 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33428 }
33429 {
33430 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33431 }
33432 {
33433 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33434 }
33435 {
33436 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33437 }
33438 {
33439 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33440 }
33441 {
33442 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33443 }
33444 {
33445 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33446 }
33447 {
33448 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33449 }
33450 {
33451 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33452 }
33453 {
33454 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33455 }
33456 {
33457 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33458 }
33459 {
33460 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33461 }
33462 {
33463 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33464 }
33465 {
33466 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33467 }
33468 {
33469 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33470 }
33471 {
33472 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33473 }
33474 {
33475 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33476 }
33477 {
33478 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33479 }
33480 {
33481 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33482 }
33483 {
33484 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33485 }
33486 {
33487 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33488 }
33489 {
33490 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33491 }
33492 {
33493 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33515 }
33516 {
33517 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33524 }
33525 {
33526 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33527 }
33528 {
33529 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33530 }
33531 {
33532 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33533 }
33534 {
33535 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33539 }
33540 {
33541 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33542 }
33543 {
33544 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33545 }
33546 {
33547 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33548 }
33549 {
33550 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33551 }
33552 {
33553 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33569 }
33570 {
33571 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33584 }
33585 {
33586 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33587 }
33588 {
33589 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33590 }
33591 {
33592 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33593 }
33594 {
33595 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33596 }
33597 {
33598 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33599 }
33600 {
33601 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33602 }
33603 {
33604 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33605 }
33606 {
33607 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33608 }
33609 {
33610 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33623 }
33624 {
33625 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33626 }
33627 {
33628 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33629 }
33630 {
33631 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33632 }
33633 {
33634 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33644 }
33645 {
33646 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33647 }
33648 {
33649 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33650 }
33651 {
33652 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33665 }
33666 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33667 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33668 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33669 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33670 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33671 {
33672 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33673 }
33674 {
33675 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33676 }
33677 {
33678 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33682 }
33683 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33684
33685 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33686
33687 {
33688 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33689 }
33690 {
33691 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33692 }
33693 {
33694 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33695 }
33696 {
33697 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33698 }
33699 {
33700 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33701 }
33702 {
33703 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33704 }
33705 {
33706 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33707 }
33708 {
33709 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33710 }
33711 {
33712 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33713 }
33714 {
33715 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33716 }
33717 {
33718 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33719 }
33720 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33721 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33722 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33723 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33724 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33725 {
33726 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33727 }
33728 {
33729 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33730 }
33731 {
33732 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33742 }
33743 {
33744 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33799 }
33800 {
33801 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33802 }
33803 {
33804 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33805 }
33806 {
33807 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33808 }
33809 {
33810 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33811 }
33812 {
33813 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33814 }
33815 {
33816 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33817 }
33818 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33819 {
33820 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33833 }
33834
33835 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33836
33837 {
33838 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33857 }
33858 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33859 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33860 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33861 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33862 {
33863 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33864 }
33865 {
33866 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33867 }
33868 {
33869 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33870 }
33871 {
33872 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33873 }
33874 {
33875 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33876 }
33877 {
33878 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33879 }
33880 {
33881 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33882 }
33883 {
33884 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33885 }
33886 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33887 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33888 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33889 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33890 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33891 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33892 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33893 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33894 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33895 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33896 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33897 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33898 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33899 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33900 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33901 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33902 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33903 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33904 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33905 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33906 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33907 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33908 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33909 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33910 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33911 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33912 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33913 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33914 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33915 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33916 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33917 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33918 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33919 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33920 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33921 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33922 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33923 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33924 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33925 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33926 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33927 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33928 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33929 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33930 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33931 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33932 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33933 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33934 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33935 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33936 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33937 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW",_wrap_ART_NEW_get, _wrap_ART_NEW_set);
33938 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33939 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33940 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33941 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33942 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33943
33944 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33945
33946 {
33947 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33948 }
33949 {
33950 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33951 }
33952 {
33953 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33954 }
33955 {
33956 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33957 }
33958 {
33959 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33960 }
33961 {
33962 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33972 }
33973 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33974 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33975 {
33976 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33977 }
33978 {
33979 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33980 }
33981 {
33982 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33983 }
33984 {
33985 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33986 }
33987 {
33988 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33989 }
33990 {
33991 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33992 }
33993 {
33994 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33995 }
33996 {
33997 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33998 }
33999 {
34000 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
34001 }
34002 {
34003 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
34004 }
34005 {
34006 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
34007 }
34008 {
34009 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
34010 }
34011 {
34012 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
34013 }
34014 {
34015 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
34016 }
34017 {
34018 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
34019 }
34020 {
34021 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
34022 }
34023 {
34024 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
34025 }
34026 {
34027 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
34028 }
34029 {
34030 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
34031 }
34032 {
34033 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
34034 }
34035 {
34036 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34037 }
34038 {
34039 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34040 }
34041 {
34042 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34043 }
34044 {
34045 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34046 }
34047 {
34048 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34049 }
34050 {
34051 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34052 }
34053 {
34054 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34055 }
34056 {
34057 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34058 }
34059 {
34060 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34061 }
34062 {
34063 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34064 }
34065 {
34066 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34067 }
34068 {
34069 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34070 }
34071 {
34072 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34073 }
34074 {
34075 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34076 }
34077 {
34078 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34079 }
34080 {
34081 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34082 }
34083 {
34084 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34085 }
34086 {
34087 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34088 }
34089 {
34090 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34091 }
34092 {
34093 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34094 }
34095 {
34096 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34097 }
34098 {
34099 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34100 }
34101 {
34102 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34103 }
34104 {
34105 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34106 }
34107 {
34108 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34109 }
34110 {
34111 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34112 }
34113 {
34114 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34115 }
34116 {
34117 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34118 }
34119 {
34120 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34121 }
34122 {
34123 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34124 }
34125 {
34126 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34127 }
34128 {
34129 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34130 }
34131 {
34132 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34133 }
34134 {
34135 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34136 }
34137 {
34138 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34139 }
34140 {
34141 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34142 }
34143 {
34144 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34145 }
34146 {
34147 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34148 }
34149 {
34150 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34151 }
34152 {
34153 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34154 }
34155 {
34156 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34157 }
34158 {
34159 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34160 }
34161 {
34162 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34163 }
34164 {
34165 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34166 }
34167 {
34168 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34169 }
34170 {
34171 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34172 }
34173 {
34174 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34175 }
34176 {
34177 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34178 }
34179 {
34180 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34181 }
34182 {
34183 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34184 }
34185 {
34186 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34187 }
34188 {
34189 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34190 }
34191 {
34192 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34193 }
34194 {
34195 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34196 }
34197 {
34198 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34199 }
34200 {
34201 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34202 }
34203 {
34204 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34205 }
34206 {
34207 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34208 }
34209 {
34210 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34211 }
34212 {
34213 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34214 }
34215 {
34216 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34217 }
34218 {
34219 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34220 }
34221 {
34222 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34223 }
34224 {
34225 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34226 }
34227 {
34228 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34229 }
34230 {
34231 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34232 }
34233 {
34234 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34235 }
34236 {
34237 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34238 }
34239 {
34240 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34241 }
34242 {
34243 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34244 }
34245 {
34246 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34247 }
34248 {
34249 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34250 }
34251 {
34252 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34253 }
34254 {
34255 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34256 }
34257 {
34258 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34259 }
34260 {
34261 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34262 }
34263 {
34264 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34265 }
34266 {
34267 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34268 }
34269 {
34270 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34271 }
34272 {
34273 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34274 }
34275 {
34276 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34277 }
34278 {
34279 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34280 }
34281 {
34282 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34283 }
34284 {
34285 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34286 }
34287 {
34288 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34289 }
34290 {
34291 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34292 }
34293 {
34294 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34295 }
34296 {
34297 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34298 }
34299 {
34300 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34301 }
34302 {
34303 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34304 }
34305 {
34306 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34307 }
34308 {
34309 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34310 }
34311 {
34312 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34313 }
34314 {
34315 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34316 }
34317 {
34318 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34319 }
34320 {
34321 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34322 }
34323 {
34324 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34325 }
34326 {
34327 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34328 }
34329 {
34330 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34331 }
34332 {
34333 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34334 }
34335 {
34336 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34337 }
34338 {
34339 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34340 }
34341 {
34342 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34343 }
34344 {
34345 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34346 }
34347 {
34348 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34349 }
34350 {
34351 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34352 }
34353 {
34354 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34355 }
34356 {
34357 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34358 }
34359 {
34360 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34361 }
34362 {
34363 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34364 }
34365 {
34366 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34367 }
34368 {
34369 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34370 }
34371 {
34372 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34373 }
34374 {
34375 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34376 }
34377 {
34378 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34379 }
34380 {
34381 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34382 }
34383 {
34384 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34385 }
34386 {
34387 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34388 }
34389 {
34390 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34391 }
34392 {
34393 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34394 }
34395 {
34396 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34397 }
34398 {
34399 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34400 }
34401 {
34402 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34403 }
34404 {
34405 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34406 }
34407 {
34408 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34409 }
34410 {
34411 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34412 }
34413 {
34414 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34415 }
34416 {
34417 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34418 }
34419 {
34420 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34421 }
34422 {
34423 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34424 }
34425 {
34426 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34427 }
34428 {
34429 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34430 }
34431 {
34432 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34433 }
34434 {
34435 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34436 }
34437 {
34438 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34439 }
34440 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34441 {
34442 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34443 }
34444 {
34445 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34446 }
34447 {
34448 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34449 }
34450 {
34451 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34452 }
34453 {
34454 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34455 }
34456 {
34457 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34458 }
34459 {
34460 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34461 }
34462 {
34463 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34464 }
34465 {
34466 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34467 }
34468 {
34469 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34470 }
34471 {
34472 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34473 }
34474 {
34475 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34476 }
34477 {
34478 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34479 }
34480 {
34481 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34482 }
34483 {
34484 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34485 }
34486 {
34487 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34488 }
34489 {
34490 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34491 }
34492 {
34493 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34494 }
34495 {
34496 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34497 }
34498 {
34499 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34500 }
34501 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34502 {
34503 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34504 }
34505 {
34506 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34507 }
34508 {
34509 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34510 }
34511 {
34512 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34513 }
34514 {
34515 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34516 }
34517 {
34518 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34519 }
34520 {
34521 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34522 }
34523 {
34524 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34525 }
34526 {
34527 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34528 }
34529 {
34530 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34531 }
34532 {
34533 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34534 }
34535 {
34536 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34537 }
34538
34539 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34540 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34541 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34542 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34543
34544 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34545 }
34546
wxWidgets (Impactor)