]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.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_wxMetafile swig_types[2]
1345 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1346 #define SWIGTYPE_p_wxLog swig_types[4]
1347 #define SWIGTYPE_p_wxMenu swig_types[5]
1348 #define SWIGTYPE_p_wxEvent swig_types[6]
1349 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1350 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1351 #define SWIGTYPE_p_wxDisplay swig_types[9]
1352 #define SWIGTYPE_p_wxFileType swig_types[10]
1353 #define SWIGTYPE_p_wxLogGui swig_types[11]
1354 #define SWIGTYPE_p_wxFont swig_types[12]
1355 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1356 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1357 #define SWIGTYPE_p_wxCaret swig_types[15]
1358 #define SWIGTYPE_ptrdiff_t swig_types[16]
1359 #define SWIGTYPE_std__ptrdiff_t 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_p_wxConfig swig_types[81]
1424 #define SWIGTYPE_unsigned_int swig_types[82]
1425 #define SWIGTYPE_p_unsigned_int 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 SWIGINTERN int
1663 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1664 {
1665 long v = 0;
1666 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1667 SWIG_type_error("unsigned number", obj);
1668 }
1669 else if (val)
1670 *val = (unsigned long)v;
1671 return 1;
1672 }
1673
1674
1675 SWIGINTERNSHORT unsigned long
1676 SWIG_As_unsigned_SS_long(PyObject* obj)
1677 {
1678 unsigned long v;
1679 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1680 /*
1681 this is needed to make valgrind/purify happier.
1682 */
1683 memset((void*)&v, 0, sizeof(unsigned long));
1684 }
1685 return v;
1686 }
1687
1688
1689 SWIGINTERNSHORT int
1690 SWIG_Check_unsigned_SS_long(PyObject* obj)
1691 {
1692 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1693 }
1694
1695
1696 SWIGINTERNSHORT PyObject*
1697 SWIG_From_unsigned_SS_long(unsigned long value)
1698 {
1699 return (value > LONG_MAX) ?
1700 PyLong_FromUnsignedLong(value)
1701 : PyInt_FromLong((long)(value));
1702 }
1703
1704
1705 bool wxThread_IsMain() {
1706 #ifdef WXP_WITH_THREAD
1707 return wxThread::IsMain();
1708 #else
1709 return true;
1710 #endif
1711 }
1712
1713 static void wxCaret_Destroy(wxCaret *self){
1714 delete self;
1715 }
1716
1717 #include <wx/snglinst.h>
1718
1719
1720 #ifdef __WXMSW__
1721 #include <wx/msw/private.h>
1722 #include <wx/dynload.h>
1723 #endif
1724
1725
1726
1727 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1728 #if 0
1729 , int method
1730 #endif
1731 )
1732 {
1733 #ifdef __WXMSW__
1734 #if 0
1735 switch (method)
1736 {
1737 case 1:
1738 // This one only partially works. Appears to be an undocumented
1739 // "standard" convention that not all widgets adhear to. For
1740 // example, for some widgets backgrounds or non-client areas may
1741 // not be painted.
1742 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1743 break;
1744
1745 case 2:
1746 #endif
1747 // This one works much better, nearly all widgets and their
1748 // children are captured correctly[**]. Prior to the big
1749 // background erase changes that Vadim did in 2004-2005 this
1750 // method failed badly on XP with Themes activated, most native
1751 // widgets draw only partially, if at all. Without themes it
1752 // worked just like on Win2k. After those changes this method
1753 // works very well.
1754 //
1755 // ** For example the radio buttons in a wxRadioBox are not its
1756 // children by default, but you can capture it via the panel
1757 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1758 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1759 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1760 PRF_ERASEBKGND | PRF_OWNED );
1761 return true;
1762 #if 0
1763 break;
1764
1765 case 3:
1766 // This one is only defined in the latest SDK and is only
1767 // available on XP. MSDN says it is similar to sending WM_PRINT
1768 // so I expect that it will work similar to the above. Since it
1769 // is avaialble only on XP, it can't be compiled like this and
1770 // will have to be loaded dynamically.
1771 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1772
1773 // fall through
1774
1775 case 4:
1776 // Use PrintWindow if available, or fallback to WM_PRINT
1777 // otherwise. Unfortunately using PrintWindow is even worse than
1778 // WM_PRINT. For most native widgets nothing is drawn to the dc
1779 // at all, with or without Themes.
1780 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1781 static bool s_triedToLoad = false;
1782 static PrintWindow_t pfnPrintWindow = NULL;
1783 if ( !s_triedToLoad )
1784 {
1785
1786 s_triedToLoad = true;
1787 wxDynamicLibrary dllUser32(_T("user32.dll"));
1788 if ( dllUser32.IsLoaded() )
1789 {
1790 wxLogNull nolog; // Don't report errors here
1791 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1792 }
1793 }
1794 if (pfnPrintWindow)
1795 {
1796 //printf("Using PrintWindow\n");
1797 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1798 }
1799 else
1800 {
1801 //printf("Using WM_PRINT\n");
1802 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1803 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1804 PRF_ERASEBKGND | PRF_OWNED );
1805 }
1806 }
1807 #endif // 0
1808 #else
1809 return false;
1810 #endif // __WXMSW__
1811 }
1812
1813
1814
1815 #include <wx/tipdlg.h>
1816
1817
1818 class wxPyTipProvider : public wxTipProvider {
1819 public:
1820 wxPyTipProvider(size_t currentTip)
1821 : wxTipProvider(currentTip) {}
1822
1823 DEC_PYCALLBACK_STRING__pure(GetTip);
1824 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1825 PYPRIVATE;
1826 };
1827
1828 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1829 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1830
1831
1832 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1833
1834 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1835
1836 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1837 : wxTimer(owner, id)
1838 {
1839 if (owner == NULL) SetOwner(this);
1840 }
1841
1842
1843 void wxPyTimer::Notify() {
1844 bool found;
1845 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1846 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1847 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1848 wxPyEndBlockThreads(blocked);
1849 if (! found)
1850 wxTimer::Notify();
1851 }
1852 void wxPyTimer::base_Notify() {
1853 wxTimer::Notify();
1854 }
1855
1856
1857
1858 SWIGINTERN PyObject *
1859 SWIG_FromCharPtr(const char* cptr)
1860 {
1861 if (cptr) {
1862 size_t size = strlen(cptr);
1863 if (size > INT_MAX) {
1864 return SWIG_NewPointerObj((char*)(cptr),
1865 SWIG_TypeQuery("char *"), 0);
1866 } else {
1867 if (size != 0) {
1868 return PyString_FromStringAndSize(cptr, size);
1869 } else {
1870 return PyString_FromString(cptr);
1871 }
1872 }
1873 }
1874 Py_INCREF(Py_None);
1875 return Py_None;
1876 }
1877
1878
1879 SWIGINTERNSHORT int
1880 SWIG_CheckUnsignedLongInRange(unsigned long value,
1881 unsigned long max_value,
1882 const char *errmsg)
1883 {
1884 if (value > max_value) {
1885 if (errmsg) {
1886 PyErr_Format(PyExc_OverflowError,
1887 "value %lu is greater than '%s' minimum %lu",
1888 value, errmsg, max_value);
1889 }
1890 return 0;
1891 }
1892 return 1;
1893 }
1894
1895
1896 #if UINT_MAX != ULONG_MAX
1897 SWIGINTERN int
1898 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1899 {
1900 const char* errmsg = val ? "unsigned int" : (char*)0;
1901 unsigned long v;
1902 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1903 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1904 if (val) *val = (unsigned int)(v);
1905 return 1;
1906 }
1907 } else {
1908 PyErr_Clear();
1909 }
1910 if (val) {
1911 SWIG_type_error(errmsg, obj);
1912 }
1913 return 0;
1914 }
1915 #else
1916 SWIGINTERNSHORT unsigned int
1917 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1918 {
1919 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1920 }
1921 #endif
1922
1923
1924 SWIGINTERNSHORT unsigned int
1925 SWIG_As_unsigned_SS_int(PyObject* obj)
1926 {
1927 unsigned int v;
1928 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1929 /*
1930 this is needed to make valgrind/purify happier.
1931 */
1932 memset((void*)&v, 0, sizeof(unsigned int));
1933 }
1934 return v;
1935 }
1936
1937
1938 SWIGINTERNSHORT int
1939 SWIG_Check_unsigned_SS_int(PyObject* obj)
1940 {
1941 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1942 }
1943
1944 static wxString Log_TimeStamp(){
1945 wxString msg;
1946 wxLog::TimeStamp(&msg);
1947 return msg;
1948 }
1949 static void wxLog_Destroy(wxLog *self){ delete self; }
1950 // Make somce wrappers that double any % signs so they are 'escaped'
1951 void wxPyLogFatalError(const wxString& msg)
1952 {
1953 wxString m(msg);
1954 m.Replace(wxT("%"), wxT("%%"));
1955 wxLogFatalError(m);
1956 }
1957
1958 void wxPyLogError(const wxString& msg)
1959 {
1960 wxString m(msg);
1961 m.Replace(wxT("%"), wxT("%%"));
1962 wxLogError(m);
1963 }
1964
1965 void wxPyLogWarning(const wxString& msg)
1966 {
1967 wxString m(msg);
1968 m.Replace(wxT("%"), wxT("%%"));
1969 wxLogWarning(m);
1970 }
1971
1972 void wxPyLogMessage(const wxString& msg)
1973 {
1974 wxString m(msg);
1975 m.Replace(wxT("%"), wxT("%%"));
1976 wxLogMessage(m);
1977 }
1978
1979 void wxPyLogInfo(const wxString& msg)
1980 {
1981 wxString m(msg);
1982 m.Replace(wxT("%"), wxT("%%"));
1983 wxLogInfo(m);
1984 }
1985
1986 void wxPyLogDebug(const wxString& msg)
1987 {
1988 wxString m(msg);
1989 m.Replace(wxT("%"), wxT("%%"));
1990 wxLogDebug(m);
1991 }
1992
1993 void wxPyLogVerbose(const wxString& msg)
1994 {
1995 wxString m(msg);
1996 m.Replace(wxT("%"), wxT("%%"));
1997 wxLogVerbose(m);
1998 }
1999
2000 void wxPyLogStatus(const wxString& msg)
2001 {
2002 wxString m(msg);
2003 m.Replace(wxT("%"), wxT("%%"));
2004 wxLogStatus(m);
2005 }
2006
2007 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2008 {
2009 wxString m(msg);
2010 m.Replace(wxT("%"), wxT("%%"));
2011 wxLogStatus(pFrame, m);
2012 }
2013
2014 void wxPyLogSysError(const wxString& msg)
2015 {
2016 wxString m(msg);
2017 m.Replace(wxT("%"), wxT("%%"));
2018 wxLogSysError(m);
2019 }
2020
2021 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2022 {
2023 wxString m(msg);
2024 m.Replace(wxT("%"), wxT("%%"));
2025 wxLogGeneric(level, m);
2026 }
2027
2028 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2029 {
2030 wxString m(msg);
2031 m.Replace(wxT("%"), wxT("%%"));
2032 wxLogTrace(mask, m);
2033 }
2034
2035 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2036 {
2037 wxString m(msg);
2038 m.Replace(wxT("%"), wxT("%%"));
2039 wxLogTrace(mask, m);
2040 }
2041
2042
2043
2044 // A wxLog class that can be derived from in wxPython
2045 class wxPyLog : public wxLog {
2046 public:
2047 wxPyLog() : wxLog() {}
2048
2049 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2050 bool found;
2051 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2052 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2053 PyObject* s = wx2PyString(szString);
2054 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2055 Py_DECREF(s);
2056 }
2057 wxPyEndBlockThreads(blocked);
2058 if (! found)
2059 wxLog::DoLog(level, szString, t);
2060 }
2061
2062 virtual void DoLogString(const wxChar *szString, time_t t) {
2063 bool found;
2064 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2065 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2066 PyObject* s = wx2PyString(szString);
2067 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2068 Py_DECREF(s);
2069 }
2070 wxPyEndBlockThreads(blocked);
2071 if (! found)
2072 wxLog::DoLogString(szString, t);
2073 }
2074
2075 PYPRIVATE;
2076 };
2077
2078
2079
2080
2081 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2082
2083
2084 #include <wx/joystick.h>
2085
2086
2087 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2088 // A C++ stub class for wxJoystick for platforms that don't have it.
2089 class wxJoystick : public wxObject {
2090 public:
2091 wxJoystick(int joystick = wxJOYSTICK1) {
2092 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2093 PyErr_SetString(PyExc_NotImplementedError,
2094 "wxJoystick is not available on this platform.");
2095 wxPyEndBlockThreads(blocked);
2096 }
2097 wxPoint GetPosition() { return wxPoint(-1,-1); }
2098 int GetZPosition() { return -1; }
2099 int GetButtonState() { return -1; }
2100 int GetPOVPosition() { return -1; }
2101 int GetPOVCTSPosition() { return -1; }
2102 int GetRudderPosition() { return -1; }
2103 int GetUPosition() { return -1; }
2104 int GetVPosition() { return -1; }
2105 int GetMovementThreshold() { return -1; }
2106 void SetMovementThreshold(int threshold) {}
2107
2108 bool IsOk(void) { return false; }
2109 int GetNumberJoysticks() { return -1; }
2110 int GetManufacturerId() { return -1; }
2111 int GetProductId() { return -1; }
2112 wxString GetProductName() { return wxEmptyString; }
2113 int GetXMin() { return -1; }
2114 int GetYMin() { return -1; }
2115 int GetZMin() { return -1; }
2116 int GetXMax() { return -1; }
2117 int GetYMax() { return -1; }
2118 int GetZMax() { return -1; }
2119 int GetNumberButtons() { return -1; }
2120 int GetNumberAxes() { return -1; }
2121 int GetMaxButtons() { return -1; }
2122 int GetMaxAxes() { return -1; }
2123 int GetPollingMin() { return -1; }
2124 int GetPollingMax() { return -1; }
2125 int GetRudderMin() { return -1; }
2126 int GetRudderMax() { return -1; }
2127 int GetUMin() { return -1; }
2128 int GetUMax() { return -1; }
2129 int GetVMin() { return -1; }
2130 int GetVMax() { return -1; }
2131
2132 bool HasRudder() { return false; }
2133 bool HasZ() { return false; }
2134 bool HasU() { return false; }
2135 bool HasV() { return false; }
2136 bool HasPOV() { return false; }
2137 bool HasPOV4Dir() { return false; }
2138 bool HasPOVCTS() { return false; }
2139
2140 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2141 bool ReleaseCapture() { return false; }
2142 };
2143 #endif
2144
2145
2146 #include <wx/sound.h>
2147
2148
2149 #if !wxUSE_SOUND
2150 // A C++ stub class for wxWave for platforms that don't have it.
2151 class wxSound : public wxObject
2152 {
2153 public:
2154 wxSound() {
2155 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2156 PyErr_SetString(PyExc_NotImplementedError,
2157 "wxSound is not available on this platform.");
2158 wxPyEndBlockThreads(blocked);
2159 }
2160 wxSound(const wxString&/*, bool*/) {
2161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2162 PyErr_SetString(PyExc_NotImplementedError,
2163 "wxSound is not available on this platform.");
2164 wxPyEndBlockThreads(blocked);
2165 }
2166 wxSound(int, const wxByte*) {
2167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2168 PyErr_SetString(PyExc_NotImplementedError,
2169 "wxSound is not available on this platform.");
2170 wxPyEndBlockThreads(blocked);
2171 }
2172
2173 ~wxSound() {};
2174
2175 bool Create(const wxString&/*, bool*/) { return false; }
2176 bool Create(int, const wxByte*) { return false; };
2177 bool IsOk() { return false; };
2178 bool Play(unsigned) const { return false; }
2179 static bool Play(const wxString&, unsigned) { return false; }
2180 static void Stop() {}
2181 };
2182
2183 #endif
2184
2185 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2186 if (fileName.Length() == 0)
2187 return new wxSound;
2188 else
2189 return new wxSound(fileName);
2190 }
2191 static wxSound *new_wxSound(PyObject *data){
2192 unsigned char* buffer; int size;
2193 wxSound *sound = NULL;
2194
2195 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2196 if (!PyArg_Parse(data, "t#", &buffer, &size))
2197 goto done;
2198 sound = new wxSound(size, buffer);
2199 done:
2200 wxPyEndBlockThreads(blocked);
2201 return sound;
2202 }
2203 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2204 #ifndef __WXMAC__
2205 unsigned char* buffer;
2206 int size;
2207 bool rv = false;
2208
2209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2210 if (!PyArg_Parse(data, "t#", &buffer, &size))
2211 goto done;
2212 rv = self->Create(size, buffer);
2213 done:
2214 wxPyEndBlockThreads(blocked);
2215 return rv;
2216 #else
2217 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2218 PyErr_SetString(PyExc_NotImplementedError,
2219 "Create from data is not available on this platform.");
2220 wxPyEndBlockThreads(blocked);
2221 return false;
2222 #endif
2223 }
2224
2225 #include <wx/mimetype.h>
2226
2227 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2228 wxString str;
2229 if (self->GetMimeType(&str))
2230 return wx2PyString(str);
2231 else
2232 RETURN_NONE();
2233 }
2234 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2235 wxArrayString arr;
2236 if (self->GetMimeTypes(arr))
2237 return wxArrayString2PyList_helper(arr);
2238 else
2239 RETURN_NONE();
2240 }
2241 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2242 wxArrayString arr;
2243 if (self->GetExtensions(arr))
2244 return wxArrayString2PyList_helper(arr);
2245 else
2246 RETURN_NONE();
2247 }
2248 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2249 wxIconLocation loc;
2250 if (self->GetIcon(&loc))
2251 return new wxIcon(loc);
2252 else
2253 return NULL;
2254 }
2255 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2256 wxIconLocation loc;
2257 if (self->GetIcon(&loc)) {
2258 wxString iconFile = loc.GetFileName();
2259 int iconIndex = -1;
2260
2261
2262
2263 // Make a tuple and put the values in it
2264 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2265 PyObject* tuple = PyTuple_New(3);
2266 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2267 wxT("wxIcon"), true));
2268 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2269 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2270 wxPyEndBlockThreads(blocked);
2271 return tuple;
2272 }
2273 else
2274 RETURN_NONE();
2275 }
2276 static PyObject *wxFileType_GetDescription(wxFileType *self){
2277 wxString str;
2278 if (self->GetDescription(&str))
2279 return wx2PyString(str);
2280 else
2281 RETURN_NONE();
2282 }
2283 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2284 wxString str;
2285 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2286 return wx2PyString(str);
2287 else
2288 RETURN_NONE();
2289 }
2290 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2291 wxString str;
2292 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2293 return wx2PyString(str);
2294 else
2295 RETURN_NONE();
2296 }
2297 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2298 wxArrayString verbs;
2299 wxArrayString commands;
2300 if (self->GetAllCommands(&verbs, &commands,
2301 wxFileType::MessageParameters(filename, mimetype))) {
2302 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2303 PyObject* tuple = PyTuple_New(2);
2304 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2305 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2306 wxPyEndBlockThreads(blocked);
2307 return tuple;
2308 }
2309 else
2310 RETURN_NONE();
2311 }
2312 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2313 return wxFileType::ExpandCommand(command,
2314 wxFileType::MessageParameters(filename, mimetype));
2315 }
2316 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2317 wxArrayString arr;
2318 self->EnumAllFileTypes(arr);
2319 return wxArrayString2PyList_helper(arr);
2320 }
2321
2322 #include <wx/artprov.h>
2323
2324 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2325 static const wxString wxPyART_MENU(wxART_MENU);
2326 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2327 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2328 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2329 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2330 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2331 static const wxString wxPyART_OTHER(wxART_OTHER);
2332 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2333 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2334 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2335 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2336 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2337 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2338 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2339 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2340 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2341 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2342 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2343 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2344 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2345 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2346 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2347 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2348 static const wxString wxPyART_PRINT(wxART_PRINT);
2349 static const wxString wxPyART_HELP(wxART_HELP);
2350 static const wxString wxPyART_TIP(wxART_TIP);
2351 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2352 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2353 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2354 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2355 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2356 static const wxString wxPyART_CDROM(wxART_CDROM);
2357 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2358 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2359 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2360 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2361 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2362 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2363 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2364 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2365 static const wxString wxPyART_ERROR(wxART_ERROR);
2366 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2367 static const wxString wxPyART_WARNING(wxART_WARNING);
2368 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2369 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2370 static const wxString wxPyART_COPY(wxART_COPY);
2371 static const wxString wxPyART_CUT(wxART_CUT);
2372 static const wxString wxPyART_PASTE(wxART_PASTE);
2373 static const wxString wxPyART_DELETE(wxART_DELETE);
2374 static const wxString wxPyART_UNDO(wxART_UNDO);
2375 static const wxString wxPyART_REDO(wxART_REDO);
2376 static const wxString wxPyART_QUIT(wxART_QUIT);
2377 static const wxString wxPyART_FIND(wxART_FIND);
2378 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2379 // Python aware wxArtProvider
2380 class wxPyArtProvider : public wxArtProvider {
2381 public:
2382
2383 virtual wxBitmap CreateBitmap(const wxArtID& id,
2384 const wxArtClient& client,
2385 const wxSize& size) {
2386 wxBitmap rval = wxNullBitmap;
2387 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2388 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2389 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2390 PyObject* ro;
2391 wxBitmap* ptr;
2392 PyObject* s1, *s2;
2393 s1 = wx2PyString(id);
2394 s2 = wx2PyString(client);
2395 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2396 Py_DECREF(so);
2397 Py_DECREF(s1);
2398 Py_DECREF(s2);
2399 if (ro) {
2400 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2401 rval = *ptr;
2402 Py_DECREF(ro);
2403 }
2404 }
2405 wxPyEndBlockThreads(blocked);
2406 return rval;
2407 }
2408
2409 PYPRIVATE;
2410 };
2411
2412 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2413
2414
2415
2416 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2417 PyObject* ret = PyTuple_New(3);
2418 if (ret) {
2419 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2420 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2421 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2422 }
2423 return ret;
2424 }
2425
2426 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2427 bool cont;
2428 long index = 0;
2429 wxString value;
2430
2431 cont = self->GetFirstGroup(value, index);
2432 return __EnumerationHelper(cont, value, index);
2433 }
2434 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2435 bool cont;
2436 wxString value;
2437
2438 cont = self->GetNextGroup(value, index);
2439 return __EnumerationHelper(cont, value, index);
2440 }
2441 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2442 bool cont;
2443 long index = 0;
2444 wxString value;
2445
2446 cont = self->GetFirstEntry(value, index);
2447 return __EnumerationHelper(cont, value, index);
2448 }
2449 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2450 bool cont;
2451 wxString value;
2452
2453 cont = self->GetNextEntry(value, index);
2454 return __EnumerationHelper(cont, value, index);
2455 }
2456 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2457 long rv;
2458 self->Read(key, &rv, defaultVal);
2459 return rv;
2460 }
2461
2462 SWIGINTERN int
2463 SWIG_AsVal_double(PyObject *obj, double* val)
2464 {
2465 if (PyNumber_Check(obj)) {
2466 if (val) *val = PyFloat_AsDouble(obj);
2467 return 1;
2468 }
2469 else {
2470 SWIG_type_error("number", obj);
2471 }
2472 return 0;
2473 }
2474
2475
2476 SWIGINTERNSHORT double
2477 SWIG_As_double(PyObject* obj)
2478 {
2479 double v;
2480 if (!SWIG_AsVal_double(obj, &v)) {
2481 /*
2482 this is needed to make valgrind/purify happier.
2483 */
2484 memset((void*)&v, 0, sizeof(double));
2485 }
2486 return v;
2487 }
2488
2489
2490 SWIGINTERNSHORT int
2491 SWIG_Check_double(PyObject* obj)
2492 {
2493 return SWIG_AsVal_double(obj, (double*)0);
2494 }
2495
2496 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2497 double rv;
2498 self->Read(key, &rv, defaultVal);
2499 return rv;
2500 }
2501
2502 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2503 #define SWIG_From_double PyFloat_FromDouble
2504 /*@@*/
2505
2506 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2507 bool rv;
2508 self->Read(key, &rv, defaultVal);
2509 return rv;
2510 }
2511
2512 #include <wx/datetime.h>
2513
2514 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2515 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2516
2517 #define LOCAL_TZ wxDateTime::Local
2518
2519 static PyObject *DateTime_GetAmPmStrings(){
2520 wxString am;
2521 wxString pm;
2522 wxDateTime::GetAmPmStrings(&am, &pm);
2523 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2524 PyObject* tup = PyTuple_New(2);
2525 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2526 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2527 wxPyEndBlockThreads(blocked);
2528 return tup;
2529 }
2530
2531 #if UINT_MAX < LONG_MAX
2532 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2533 #define SWIG_From_unsigned_SS_int SWIG_From_long
2534 /*@@*/
2535 #else
2536 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2537 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2538 /*@@*/
2539 #endif
2540
2541 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2542 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2543 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2544 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2545 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2546 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2547 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2548 return (*self < *other);
2549 }
2550 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2551 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2552 return (*self <= *other);
2553 }
2554 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2555 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2556 return (*self > *other);
2557 }
2558 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2559 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2560 return (*self >= *other);
2561 }
2562 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2563 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2564 return (*self == *other);
2565 }
2566 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2567 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2568 return (*self != *other);
2569 }
2570 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2571 const wxChar* rv;
2572 const wxChar* _date = date;
2573 rv = self->ParseRfc822Date(_date);
2574 if (rv == NULL) return -1;
2575 return rv - _date;
2576 }
2577 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2578 const wxChar* rv;
2579 const wxChar* _date = date;
2580 rv = self->ParseFormat(_date, format, dateDef);
2581 if (rv == NULL) return -1;
2582 return rv - _date;
2583 }
2584 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2585 const wxChar* rv;
2586 const wxChar* _datetime = datetime;
2587 rv = self->ParseDateTime(_datetime);
2588 if (rv == NULL) return -1;
2589 return rv - _datetime;
2590 }
2591 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2592 const wxChar* rv;
2593 const wxChar* _date = date;
2594 rv = self->ParseDate(_date);
2595 if (rv == NULL) return -1;
2596 return rv - _date;
2597 }
2598 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2599 const wxChar* rv;
2600 const wxChar* _time = time;
2601 rv = self->ParseTime(_time);
2602 if (rv == NULL) return -1;
2603 return rv - _time;
2604 }
2605 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2606 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2607 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2608 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2609 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2610 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2611 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2612 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2613 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2614 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2615 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2616 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2617 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2618 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2619 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2620 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2621
2622 #include <wx/dataobj.h>
2623
2624 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2625 size_t count = self->GetFormatCount(dir);
2626 wxDataFormat* formats = new wxDataFormat[count];
2627 self->GetAllFormats(formats, dir);
2628
2629 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2630 PyObject* list = PyList_New(count);
2631 for (size_t i=0; i<count; i++) {
2632 wxDataFormat* format = new wxDataFormat(formats[i]);
2633 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2634 PyList_Append(list, obj);
2635 Py_DECREF(obj);
2636 }
2637 wxPyEndBlockThreads(blocked);
2638 delete [] formats;
2639 return list;
2640 }
2641 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2642 PyObject* rval = NULL;
2643 size_t size = self->GetDataSize(format);
2644 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2645 if (size) {
2646 char* buf = new char[size];
2647 if (self->GetDataHere(format, buf))
2648 rval = PyString_FromStringAndSize(buf, size);
2649 delete [] buf;
2650 }
2651 if (! rval) {
2652 rval = Py_None;
2653 Py_INCREF(rval);
2654 }
2655 wxPyEndBlockThreads(blocked);
2656 return rval;
2657 }
2658 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2659 bool rval;
2660 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2661 if (PyString_Check(data)) {
2662 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2663 }
2664 else {
2665 // raise a TypeError if not a string
2666 PyErr_SetString(PyExc_TypeError, "String expected.");
2667 rval = false;
2668 }
2669 wxPyEndBlockThreads(blocked);
2670 return rval;
2671 }
2672 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2673 PyObject* rval = NULL;
2674 size_t size = self->GetDataSize();
2675 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2676 if (size) {
2677 char* buf = new char[size];
2678 if (self->GetDataHere(buf))
2679 rval = PyString_FromStringAndSize(buf, size);
2680 delete [] buf;
2681 }
2682 if (! rval) {
2683 rval = Py_None;
2684 Py_INCREF(rval);
2685 }
2686 wxPyEndBlockThreads(blocked);
2687 return rval;
2688 }
2689 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2690 bool rval;
2691 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2692 if (PyString_Check(data)) {
2693 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2694 }
2695 else {
2696 // raise a TypeError if not a string
2697 PyErr_SetString(PyExc_TypeError, "String expected.");
2698 rval = false;
2699 }
2700 wxPyEndBlockThreads(blocked);
2701 return rval;
2702 }
2703 // Create a new class for wxPython to use
2704 class wxPyDataObjectSimple : public wxDataObjectSimple {
2705 public:
2706 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2707 : wxDataObjectSimple(format) {}
2708
2709 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2710 bool GetDataHere(void *buf) const;
2711 bool SetData(size_t len, const void *buf) const;
2712 PYPRIVATE;
2713 };
2714
2715 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2716
2717 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2718 // We need to get the data for this object and write it to buf. I think
2719 // the best way to do this for wxPython is to have the Python method
2720 // return either a string or None and then act appropriately with the
2721 // C++ version.
2722
2723 bool rval = false;
2724 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2725 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2726 PyObject* ro;
2727 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2728 if (ro) {
2729 rval = (ro != Py_None && PyString_Check(ro));
2730 if (rval)
2731 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2732 Py_DECREF(ro);
2733 }
2734 }
2735 wxPyEndBlockThreads(blocked);
2736 return rval;
2737 }
2738
2739 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2740 // For this one we simply need to make a string from buf and len
2741 // and send it to the Python method.
2742 bool rval = false;
2743 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2744 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2745 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2746 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2747 Py_DECREF(data);
2748 }
2749 wxPyEndBlockThreads(blocked);
2750 return rval;
2751 }
2752
2753 // Create a new class for wxPython to use
2754 class wxPyTextDataObject : public wxTextDataObject {
2755 public:
2756 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2757 : wxTextDataObject(text) {}
2758
2759 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2760 DEC_PYCALLBACK_STRING__const(GetText);
2761 DEC_PYCALLBACK__STRING(SetText);
2762 PYPRIVATE;
2763 };
2764
2765 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2766 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2767 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2768
2769
2770 // Create a new class for wxPython to use
2771 class wxPyBitmapDataObject : public wxBitmapDataObject {
2772 public:
2773 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2774 : wxBitmapDataObject(bitmap) {}
2775
2776 wxBitmap GetBitmap() const;
2777 void SetBitmap(const wxBitmap& bitmap);
2778 PYPRIVATE;
2779 };
2780
2781 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2782 wxBitmap* rval = &wxNullBitmap;
2783 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2784 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2785 PyObject* ro;
2786 wxBitmap* ptr;
2787 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2788 if (ro) {
2789 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2790 rval = ptr;
2791 Py_DECREF(ro);
2792 }
2793 }
2794 wxPyEndBlockThreads(blocked);
2795 return *rval;
2796 }
2797
2798 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2799 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2800 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2801 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2802 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2803 Py_DECREF(bo);
2804 }
2805 wxPyEndBlockThreads(blocked);
2806 }
2807
2808 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2809 return new wxCustomDataObject(wxDataFormat(formatName));
2810 }
2811 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2812 bool rval;
2813 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2814 if (PyString_Check(data)) {
2815 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2816 }
2817 else {
2818 // raise a TypeError if not a string
2819 PyErr_SetString(PyExc_TypeError, "String expected.");
2820 rval = false;
2821 }
2822 wxPyEndBlockThreads(blocked);
2823 return rval;
2824 }
2825 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2826 PyObject* obj;
2827 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2828 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2829 wxPyEndBlockThreads(blocked);
2830 return obj;
2831 }
2832
2833 #include <wx/metafile.h>
2834
2835
2836 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2837
2838
2839 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2840 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2841 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2842 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2843 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2844
2845
2846 class wxPyTextDropTarget : public wxTextDropTarget {
2847 public:
2848 wxPyTextDropTarget() {}
2849
2850 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2851
2852 DEC_PYCALLBACK__(OnLeave);
2853 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2854 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2855 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2856 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2857
2858 PYPRIVATE;
2859 };
2860
2861 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2862 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2863 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2864 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2865 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2866 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2867
2868
2869
2870 class wxPyFileDropTarget : public wxFileDropTarget {
2871 public:
2872 wxPyFileDropTarget() {}
2873
2874 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2875
2876 DEC_PYCALLBACK__(OnLeave);
2877 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2878 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2879 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2880 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2881
2882 PYPRIVATE;
2883 };
2884
2885 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2886 const wxArrayString& filenames) {
2887 bool rval = false;
2888 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2889 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2890 PyObject* list = wxArrayString2PyList_helper(filenames);
2891 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2892 Py_DECREF(list);
2893 }
2894 wxPyEndBlockThreads(blocked);
2895 return rval;
2896 }
2897
2898
2899
2900 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2901 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2902 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2903 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2904 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2905
2906
2907
2908
2909 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2910
2911 #include <wx/display.h>
2912
2913 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2914 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2915
2916 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2917 #if !wxUSE_DISPLAY
2918 #include <wx/dynarray.h>
2919 #include <wx/vidmode.h>
2920
2921 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2922 #include "wx/arrimpl.cpp"
2923 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2924 const wxVideoMode wxDefaultVideoMode;
2925
2926 class wxDisplay
2927 {
2928 public:
2929 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2930 ~wxDisplay() {}
2931
2932 static size_t GetCount()
2933 { wxPyRaiseNotImplemented(); return 0; }
2934
2935 static int GetFromPoint(const wxPoint& pt)
2936 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2937 static int GetFromWindow(wxWindow *window)
2938 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2939
2940 virtual bool IsOk() const { return false; }
2941 virtual wxRect GetGeometry() const { wxRect r; return r; }
2942 virtual wxString GetName() const { return wxEmptyString; }
2943 bool IsPrimary() const { return false; }
2944
2945 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2946 { wxArrayVideoModes a; return a; }
2947
2948 virtual wxVideoMode GetCurrentMode() const
2949 { return wxDefaultVideoMode; }
2950
2951 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2952 { return false; }
2953
2954 void ResetMode() {}
2955 };
2956 #endif
2957
2958 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2959 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2960 PyObject* pyList = NULL;
2961 wxArrayVideoModes arr = self->GetModes(mode);
2962 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2963 pyList = PyList_New(0);
2964 for (int i=0; i < arr.GetCount(); i++) {
2965 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2966 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2967 PyList_Append(pyList, pyObj);
2968 Py_DECREF(pyObj);
2969 }
2970 wxPyEndBlockThreads(blocked);
2971 return pyList;
2972 }
2973
2974 #include <wx/stdpaths.h>
2975
2976 static wxStandardPaths *StandardPaths_Get(){
2977 return (wxStandardPaths*) &wxStandardPaths::Get();
2978 }
2979 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2980 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2981 #ifdef __cplusplus
2982 extern "C" {
2983 #endif
2984 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2985 PyObject *resultobj;
2986 wxSystemColour arg1 ;
2987 wxColour result;
2988 PyObject * obj0 = 0 ;
2989 char *kwnames[] = {
2990 (char *) "index", NULL
2991 };
2992
2993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2994 {
2995 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2996 if (SWIG_arg_fail(1)) SWIG_fail;
2997 }
2998 {
2999 if (!wxPyCheckForApp()) SWIG_fail;
3000 PyThreadState* __tstate = wxPyBeginAllowThreads();
3001 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3002
3003 wxPyEndAllowThreads(__tstate);
3004 if (PyErr_Occurred()) SWIG_fail;
3005 }
3006 {
3007 wxColour * resultptr;
3008 resultptr = new wxColour((wxColour &)(result));
3009 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3010 }
3011 return resultobj;
3012 fail:
3013 return NULL;
3014 }
3015
3016
3017 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3018 PyObject *resultobj;
3019 wxSystemFont arg1 ;
3020 wxFont result;
3021 PyObject * obj0 = 0 ;
3022 char *kwnames[] = {
3023 (char *) "index", NULL
3024 };
3025
3026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3027 {
3028 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3029 if (SWIG_arg_fail(1)) SWIG_fail;
3030 }
3031 {
3032 if (!wxPyCheckForApp()) SWIG_fail;
3033 PyThreadState* __tstate = wxPyBeginAllowThreads();
3034 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3035
3036 wxPyEndAllowThreads(__tstate);
3037 if (PyErr_Occurred()) SWIG_fail;
3038 }
3039 {
3040 wxFont * resultptr;
3041 resultptr = new wxFont((wxFont &)(result));
3042 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3043 }
3044 return resultobj;
3045 fail:
3046 return NULL;
3047 }
3048
3049
3050 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3051 PyObject *resultobj;
3052 wxSystemMetric arg1 ;
3053 wxWindow *arg2 = (wxWindow *) NULL ;
3054 int result;
3055 PyObject * obj0 = 0 ;
3056 PyObject * obj1 = 0 ;
3057 char *kwnames[] = {
3058 (char *) "index",(char *) "win", NULL
3059 };
3060
3061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3062 {
3063 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3064 if (SWIG_arg_fail(1)) SWIG_fail;
3065 }
3066 if (obj1) {
3067 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3068 if (SWIG_arg_fail(2)) SWIG_fail;
3069 }
3070 {
3071 if (!wxPyCheckForApp()) SWIG_fail;
3072 PyThreadState* __tstate = wxPyBeginAllowThreads();
3073 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3074
3075 wxPyEndAllowThreads(__tstate);
3076 if (PyErr_Occurred()) SWIG_fail;
3077 }
3078 {
3079 resultobj = SWIG_From_int((int)(result));
3080 }
3081 return resultobj;
3082 fail:
3083 return NULL;
3084 }
3085
3086
3087 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3088 PyObject *resultobj;
3089 wxSystemFeature arg1 ;
3090 bool result;
3091 PyObject * obj0 = 0 ;
3092 char *kwnames[] = {
3093 (char *) "index", NULL
3094 };
3095
3096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3097 {
3098 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3099 if (SWIG_arg_fail(1)) SWIG_fail;
3100 }
3101 {
3102 if (!wxPyCheckForApp()) SWIG_fail;
3103 PyThreadState* __tstate = wxPyBeginAllowThreads();
3104 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3105
3106 wxPyEndAllowThreads(__tstate);
3107 if (PyErr_Occurred()) SWIG_fail;
3108 }
3109 {
3110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3111 }
3112 return resultobj;
3113 fail:
3114 return NULL;
3115 }
3116
3117
3118 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3119 PyObject *resultobj;
3120 wxSystemScreenType result;
3121 char *kwnames[] = {
3122 NULL
3123 };
3124
3125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3126 {
3127 if (!wxPyCheckForApp()) SWIG_fail;
3128 PyThreadState* __tstate = wxPyBeginAllowThreads();
3129 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3130
3131 wxPyEndAllowThreads(__tstate);
3132 if (PyErr_Occurred()) SWIG_fail;
3133 }
3134 resultobj = SWIG_From_int((result));
3135 return resultobj;
3136 fail:
3137 return NULL;
3138 }
3139
3140
3141 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3142 PyObject *resultobj;
3143 wxSystemScreenType arg1 ;
3144 PyObject * obj0 = 0 ;
3145 char *kwnames[] = {
3146 (char *) "screen", NULL
3147 };
3148
3149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3150 {
3151 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3152 if (SWIG_arg_fail(1)) SWIG_fail;
3153 }
3154 {
3155 if (!wxPyCheckForApp()) SWIG_fail;
3156 PyThreadState* __tstate = wxPyBeginAllowThreads();
3157 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3158
3159 wxPyEndAllowThreads(__tstate);
3160 if (PyErr_Occurred()) SWIG_fail;
3161 }
3162 Py_INCREF(Py_None); resultobj = Py_None;
3163 return resultobj;
3164 fail:
3165 return NULL;
3166 }
3167
3168
3169 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3170 PyObject *obj;
3171 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3172 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3173 Py_INCREF(obj);
3174 return Py_BuildValue((char *)"");
3175 }
3176 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3177 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3178 return 1;
3179 }
3180
3181
3182 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3183 PyObject *pyobj;
3184
3185 {
3186 #if wxUSE_UNICODE
3187 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3188 #else
3189 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3190 #endif
3191 }
3192 return pyobj;
3193 }
3194
3195
3196 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3197 PyObject *resultobj;
3198 wxSystemOptions *result;
3199 char *kwnames[] = {
3200 NULL
3201 };
3202
3203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3204 {
3205 PyThreadState* __tstate = wxPyBeginAllowThreads();
3206 result = (wxSystemOptions *)new wxSystemOptions();
3207
3208 wxPyEndAllowThreads(__tstate);
3209 if (PyErr_Occurred()) SWIG_fail;
3210 }
3211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3212 return resultobj;
3213 fail:
3214 return NULL;
3215 }
3216
3217
3218 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3219 PyObject *resultobj;
3220 wxString *arg1 = 0 ;
3221 wxString *arg2 = 0 ;
3222 bool temp1 = false ;
3223 bool temp2 = false ;
3224 PyObject * obj0 = 0 ;
3225 PyObject * obj1 = 0 ;
3226 char *kwnames[] = {
3227 (char *) "name",(char *) "value", NULL
3228 };
3229
3230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3231 {
3232 arg1 = wxString_in_helper(obj0);
3233 if (arg1 == NULL) SWIG_fail;
3234 temp1 = true;
3235 }
3236 {
3237 arg2 = wxString_in_helper(obj1);
3238 if (arg2 == NULL) SWIG_fail;
3239 temp2 = true;
3240 }
3241 {
3242 PyThreadState* __tstate = wxPyBeginAllowThreads();
3243 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3244
3245 wxPyEndAllowThreads(__tstate);
3246 if (PyErr_Occurred()) SWIG_fail;
3247 }
3248 Py_INCREF(Py_None); resultobj = Py_None;
3249 {
3250 if (temp1)
3251 delete arg1;
3252 }
3253 {
3254 if (temp2)
3255 delete arg2;
3256 }
3257 return resultobj;
3258 fail:
3259 {
3260 if (temp1)
3261 delete arg1;
3262 }
3263 {
3264 if (temp2)
3265 delete arg2;
3266 }
3267 return NULL;
3268 }
3269
3270
3271 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3272 PyObject *resultobj;
3273 wxString *arg1 = 0 ;
3274 int arg2 ;
3275 bool temp1 = false ;
3276 PyObject * obj0 = 0 ;
3277 PyObject * obj1 = 0 ;
3278 char *kwnames[] = {
3279 (char *) "name",(char *) "value", NULL
3280 };
3281
3282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3283 {
3284 arg1 = wxString_in_helper(obj0);
3285 if (arg1 == NULL) SWIG_fail;
3286 temp1 = true;
3287 }
3288 {
3289 arg2 = (int)(SWIG_As_int(obj1));
3290 if (SWIG_arg_fail(2)) SWIG_fail;
3291 }
3292 {
3293 PyThreadState* __tstate = wxPyBeginAllowThreads();
3294 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3295
3296 wxPyEndAllowThreads(__tstate);
3297 if (PyErr_Occurred()) SWIG_fail;
3298 }
3299 Py_INCREF(Py_None); resultobj = Py_None;
3300 {
3301 if (temp1)
3302 delete arg1;
3303 }
3304 return resultobj;
3305 fail:
3306 {
3307 if (temp1)
3308 delete arg1;
3309 }
3310 return NULL;
3311 }
3312
3313
3314 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3315 PyObject *resultobj;
3316 wxString *arg1 = 0 ;
3317 wxString result;
3318 bool temp1 = false ;
3319 PyObject * obj0 = 0 ;
3320 char *kwnames[] = {
3321 (char *) "name", NULL
3322 };
3323
3324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3325 {
3326 arg1 = wxString_in_helper(obj0);
3327 if (arg1 == NULL) SWIG_fail;
3328 temp1 = true;
3329 }
3330 {
3331 PyThreadState* __tstate = wxPyBeginAllowThreads();
3332 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3333
3334 wxPyEndAllowThreads(__tstate);
3335 if (PyErr_Occurred()) SWIG_fail;
3336 }
3337 {
3338 #if wxUSE_UNICODE
3339 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3340 #else
3341 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3342 #endif
3343 }
3344 {
3345 if (temp1)
3346 delete arg1;
3347 }
3348 return resultobj;
3349 fail:
3350 {
3351 if (temp1)
3352 delete arg1;
3353 }
3354 return NULL;
3355 }
3356
3357
3358 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3359 PyObject *resultobj;
3360 wxString *arg1 = 0 ;
3361 int result;
3362 bool temp1 = false ;
3363 PyObject * obj0 = 0 ;
3364 char *kwnames[] = {
3365 (char *) "name", NULL
3366 };
3367
3368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3369 {
3370 arg1 = wxString_in_helper(obj0);
3371 if (arg1 == NULL) SWIG_fail;
3372 temp1 = true;
3373 }
3374 {
3375 PyThreadState* __tstate = wxPyBeginAllowThreads();
3376 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3377
3378 wxPyEndAllowThreads(__tstate);
3379 if (PyErr_Occurred()) SWIG_fail;
3380 }
3381 {
3382 resultobj = SWIG_From_int((int)(result));
3383 }
3384 {
3385 if (temp1)
3386 delete arg1;
3387 }
3388 return resultobj;
3389 fail:
3390 {
3391 if (temp1)
3392 delete arg1;
3393 }
3394 return NULL;
3395 }
3396
3397
3398 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3399 PyObject *resultobj;
3400 wxString *arg1 = 0 ;
3401 bool result;
3402 bool temp1 = false ;
3403 PyObject * obj0 = 0 ;
3404 char *kwnames[] = {
3405 (char *) "name", NULL
3406 };
3407
3408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3409 {
3410 arg1 = wxString_in_helper(obj0);
3411 if (arg1 == NULL) SWIG_fail;
3412 temp1 = true;
3413 }
3414 {
3415 PyThreadState* __tstate = wxPyBeginAllowThreads();
3416 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3417
3418 wxPyEndAllowThreads(__tstate);
3419 if (PyErr_Occurred()) SWIG_fail;
3420 }
3421 {
3422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3423 }
3424 {
3425 if (temp1)
3426 delete arg1;
3427 }
3428 return resultobj;
3429 fail:
3430 {
3431 if (temp1)
3432 delete arg1;
3433 }
3434 return NULL;
3435 }
3436
3437
3438 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3439 PyObject *resultobj;
3440 wxString *arg1 = 0 ;
3441 bool result;
3442 bool temp1 = false ;
3443 PyObject * obj0 = 0 ;
3444 char *kwnames[] = {
3445 (char *) "name", NULL
3446 };
3447
3448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3449 {
3450 arg1 = wxString_in_helper(obj0);
3451 if (arg1 == NULL) SWIG_fail;
3452 temp1 = true;
3453 }
3454 {
3455 PyThreadState* __tstate = wxPyBeginAllowThreads();
3456 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3457
3458 wxPyEndAllowThreads(__tstate);
3459 if (PyErr_Occurred()) SWIG_fail;
3460 }
3461 {
3462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3463 }
3464 {
3465 if (temp1)
3466 delete arg1;
3467 }
3468 return resultobj;
3469 fail:
3470 {
3471 if (temp1)
3472 delete arg1;
3473 }
3474 return NULL;
3475 }
3476
3477
3478 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3479 PyObject *obj;
3480 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3481 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3482 Py_INCREF(obj);
3483 return Py_BuildValue((char *)"");
3484 }
3485 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3486 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3487 return 1;
3488 }
3489
3490
3491 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3492 PyObject *pyobj;
3493
3494 {
3495 #if wxUSE_UNICODE
3496 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3497 #else
3498 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3499 #endif
3500 }
3501 return pyobj;
3502 }
3503
3504
3505 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3506 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3507 return 1;
3508 }
3509
3510
3511 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3512 PyObject *pyobj;
3513
3514 {
3515 #if wxUSE_UNICODE
3516 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3517 #else
3518 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3519 #endif
3520 }
3521 return pyobj;
3522 }
3523
3524
3525 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3526 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3527 return 1;
3528 }
3529
3530
3531 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3532 PyObject *pyobj;
3533
3534 {
3535 #if wxUSE_UNICODE
3536 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3537 #else
3538 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3539 #endif
3540 }
3541 return pyobj;
3542 }
3543
3544
3545 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3546 PyObject *resultobj;
3547 long result;
3548 char *kwnames[] = {
3549 NULL
3550 };
3551
3552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3553 {
3554 PyThreadState* __tstate = wxPyBeginAllowThreads();
3555 result = (long)wxNewId();
3556
3557 wxPyEndAllowThreads(__tstate);
3558 if (PyErr_Occurred()) SWIG_fail;
3559 }
3560 {
3561 resultobj = SWIG_From_long((long)(result));
3562 }
3563 return resultobj;
3564 fail:
3565 return NULL;
3566 }
3567
3568
3569 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3570 PyObject *resultobj;
3571 long arg1 ;
3572 PyObject * obj0 = 0 ;
3573 char *kwnames[] = {
3574 (char *) "id", NULL
3575 };
3576
3577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3578 {
3579 arg1 = (long)(SWIG_As_long(obj0));
3580 if (SWIG_arg_fail(1)) SWIG_fail;
3581 }
3582 {
3583 PyThreadState* __tstate = wxPyBeginAllowThreads();
3584 wxRegisterId(arg1);
3585
3586 wxPyEndAllowThreads(__tstate);
3587 if (PyErr_Occurred()) SWIG_fail;
3588 }
3589 Py_INCREF(Py_None); resultobj = Py_None;
3590 return resultobj;
3591 fail:
3592 return NULL;
3593 }
3594
3595
3596 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3597 PyObject *resultobj;
3598 long result;
3599 char *kwnames[] = {
3600 NULL
3601 };
3602
3603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3604 {
3605 PyThreadState* __tstate = wxPyBeginAllowThreads();
3606 result = (long)wxGetCurrentId();
3607
3608 wxPyEndAllowThreads(__tstate);
3609 if (PyErr_Occurred()) SWIG_fail;
3610 }
3611 {
3612 resultobj = SWIG_From_long((long)(result));
3613 }
3614 return resultobj;
3615 fail:
3616 return NULL;
3617 }
3618
3619
3620 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3621 PyObject *resultobj;
3622 int arg1 ;
3623 bool result;
3624 PyObject * obj0 = 0 ;
3625 char *kwnames[] = {
3626 (char *) "id", NULL
3627 };
3628
3629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3630 {
3631 arg1 = (int)(SWIG_As_int(obj0));
3632 if (SWIG_arg_fail(1)) SWIG_fail;
3633 }
3634 {
3635 PyThreadState* __tstate = wxPyBeginAllowThreads();
3636 result = (bool)wxIsStockID(arg1);
3637
3638 wxPyEndAllowThreads(__tstate);
3639 if (PyErr_Occurred()) SWIG_fail;
3640 }
3641 {
3642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3643 }
3644 return resultobj;
3645 fail:
3646 return NULL;
3647 }
3648
3649
3650 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3651 PyObject *resultobj;
3652 int arg1 ;
3653 wxString *arg2 = 0 ;
3654 bool result;
3655 bool temp2 = false ;
3656 PyObject * obj0 = 0 ;
3657 PyObject * obj1 = 0 ;
3658 char *kwnames[] = {
3659 (char *) "id",(char *) "label", NULL
3660 };
3661
3662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3663 {
3664 arg1 = (int)(SWIG_As_int(obj0));
3665 if (SWIG_arg_fail(1)) SWIG_fail;
3666 }
3667 {
3668 arg2 = wxString_in_helper(obj1);
3669 if (arg2 == NULL) SWIG_fail;
3670 temp2 = true;
3671 }
3672 {
3673 PyThreadState* __tstate = wxPyBeginAllowThreads();
3674 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3675
3676 wxPyEndAllowThreads(__tstate);
3677 if (PyErr_Occurred()) SWIG_fail;
3678 }
3679 {
3680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3681 }
3682 {
3683 if (temp2)
3684 delete arg2;
3685 }
3686 return resultobj;
3687 fail:
3688 {
3689 if (temp2)
3690 delete arg2;
3691 }
3692 return NULL;
3693 }
3694
3695
3696 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3697 PyObject *resultobj;
3698 int arg1 ;
3699 bool arg2 = (bool) true ;
3700 wxString arg3 = (wxString) wxPyEmptyString ;
3701 wxString result;
3702 PyObject * obj0 = 0 ;
3703 PyObject * obj1 = 0 ;
3704 PyObject * obj2 = 0 ;
3705 char *kwnames[] = {
3706 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3707 };
3708
3709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3710 {
3711 arg1 = (int)(SWIG_As_int(obj0));
3712 if (SWIG_arg_fail(1)) SWIG_fail;
3713 }
3714 if (obj1) {
3715 {
3716 arg2 = (bool)(SWIG_As_bool(obj1));
3717 if (SWIG_arg_fail(2)) SWIG_fail;
3718 }
3719 }
3720 if (obj2) {
3721 {
3722 wxString* sptr = wxString_in_helper(obj2);
3723 if (sptr == NULL) SWIG_fail;
3724 arg3 = *sptr;
3725 delete sptr;
3726 }
3727 }
3728 {
3729 PyThreadState* __tstate = wxPyBeginAllowThreads();
3730 result = wxGetStockLabel(arg1,arg2,arg3);
3731
3732 wxPyEndAllowThreads(__tstate);
3733 if (PyErr_Occurred()) SWIG_fail;
3734 }
3735 {
3736 #if wxUSE_UNICODE
3737 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3738 #else
3739 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3740 #endif
3741 }
3742 return resultobj;
3743 fail:
3744 return NULL;
3745 }
3746
3747
3748 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3749 PyObject *resultobj;
3750 char *kwnames[] = {
3751 NULL
3752 };
3753
3754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3755 {
3756 if (!wxPyCheckForApp()) SWIG_fail;
3757 PyThreadState* __tstate = wxPyBeginAllowThreads();
3758 wxBell();
3759
3760 wxPyEndAllowThreads(__tstate);
3761 if (PyErr_Occurred()) SWIG_fail;
3762 }
3763 Py_INCREF(Py_None); resultobj = Py_None;
3764 return resultobj;
3765 fail:
3766 return NULL;
3767 }
3768
3769
3770 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3771 PyObject *resultobj;
3772 char *kwnames[] = {
3773 NULL
3774 };
3775
3776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3777 {
3778 if (!wxPyCheckForApp()) SWIG_fail;
3779 PyThreadState* __tstate = wxPyBeginAllowThreads();
3780 wxEndBusyCursor();
3781
3782 wxPyEndAllowThreads(__tstate);
3783 if (PyErr_Occurred()) SWIG_fail;
3784 }
3785 Py_INCREF(Py_None); resultobj = Py_None;
3786 return resultobj;
3787 fail:
3788 return NULL;
3789 }
3790
3791
3792 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3793 PyObject *resultobj;
3794 bool arg1 = (bool) true ;
3795 long result;
3796 PyObject * obj0 = 0 ;
3797 char *kwnames[] = {
3798 (char *) "resetTimer", NULL
3799 };
3800
3801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3802 if (obj0) {
3803 {
3804 arg1 = (bool)(SWIG_As_bool(obj0));
3805 if (SWIG_arg_fail(1)) SWIG_fail;
3806 }
3807 }
3808 {
3809 PyThreadState* __tstate = wxPyBeginAllowThreads();
3810 result = (long)wxGetElapsedTime(arg1);
3811
3812 wxPyEndAllowThreads(__tstate);
3813 if (PyErr_Occurred()) SWIG_fail;
3814 }
3815 {
3816 resultobj = SWIG_From_long((long)(result));
3817 }
3818 return resultobj;
3819 fail:
3820 return NULL;
3821 }
3822
3823
3824 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3825 PyObject *resultobj;
3826 int *arg1 = (int *) 0 ;
3827 int *arg2 = (int *) 0 ;
3828 int temp1 ;
3829 int res1 = 0 ;
3830 int temp2 ;
3831 int res2 = 0 ;
3832 char *kwnames[] = {
3833 NULL
3834 };
3835
3836 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3837 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3839 {
3840 if (!wxPyCheckForApp()) SWIG_fail;
3841 PyThreadState* __tstate = wxPyBeginAllowThreads();
3842 wxGetMousePosition(arg1,arg2);
3843
3844 wxPyEndAllowThreads(__tstate);
3845 if (PyErr_Occurred()) SWIG_fail;
3846 }
3847 Py_INCREF(Py_None); resultobj = Py_None;
3848 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3849 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3850 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3851 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3852 return resultobj;
3853 fail:
3854 return NULL;
3855 }
3856
3857
3858 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3859 PyObject *resultobj;
3860 bool result;
3861 char *kwnames[] = {
3862 NULL
3863 };
3864
3865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3866 {
3867 PyThreadState* __tstate = wxPyBeginAllowThreads();
3868 result = (bool)wxIsBusy();
3869
3870 wxPyEndAllowThreads(__tstate);
3871 if (PyErr_Occurred()) SWIG_fail;
3872 }
3873 {
3874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3875 }
3876 return resultobj;
3877 fail:
3878 return NULL;
3879 }
3880
3881
3882 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3883 PyObject *resultobj;
3884 wxString result;
3885 char *kwnames[] = {
3886 NULL
3887 };
3888
3889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3890 {
3891 PyThreadState* __tstate = wxPyBeginAllowThreads();
3892 result = wxNow();
3893
3894 wxPyEndAllowThreads(__tstate);
3895 if (PyErr_Occurred()) SWIG_fail;
3896 }
3897 {
3898 #if wxUSE_UNICODE
3899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3900 #else
3901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3902 #endif
3903 }
3904 return resultobj;
3905 fail:
3906 return NULL;
3907 }
3908
3909
3910 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3911 PyObject *resultobj;
3912 wxString const &arg1_defvalue = wxPyEmptyString ;
3913 wxString *arg1 = (wxString *) &arg1_defvalue ;
3914 bool result;
3915 bool temp1 = false ;
3916 PyObject * obj0 = 0 ;
3917 char *kwnames[] = {
3918 (char *) "command", NULL
3919 };
3920
3921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3922 if (obj0) {
3923 {
3924 arg1 = wxString_in_helper(obj0);
3925 if (arg1 == NULL) SWIG_fail;
3926 temp1 = true;
3927 }
3928 }
3929 {
3930 PyThreadState* __tstate = wxPyBeginAllowThreads();
3931 result = (bool)wxShell((wxString const &)*arg1);
3932
3933 wxPyEndAllowThreads(__tstate);
3934 if (PyErr_Occurred()) SWIG_fail;
3935 }
3936 {
3937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3938 }
3939 {
3940 if (temp1)
3941 delete arg1;
3942 }
3943 return resultobj;
3944 fail:
3945 {
3946 if (temp1)
3947 delete arg1;
3948 }
3949 return NULL;
3950 }
3951
3952
3953 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3954 PyObject *resultobj;
3955 char *kwnames[] = {
3956 NULL
3957 };
3958
3959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3960 {
3961 PyThreadState* __tstate = wxPyBeginAllowThreads();
3962 wxStartTimer();
3963
3964 wxPyEndAllowThreads(__tstate);
3965 if (PyErr_Occurred()) SWIG_fail;
3966 }
3967 Py_INCREF(Py_None); resultobj = Py_None;
3968 return resultobj;
3969 fail:
3970 return NULL;
3971 }
3972
3973
3974 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3975 PyObject *resultobj;
3976 int *arg1 = (int *) 0 ;
3977 int *arg2 = (int *) 0 ;
3978 int result;
3979 int temp1 ;
3980 int res1 = 0 ;
3981 int temp2 ;
3982 int res2 = 0 ;
3983 char *kwnames[] = {
3984 NULL
3985 };
3986
3987 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3988 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3990 {
3991 PyThreadState* __tstate = wxPyBeginAllowThreads();
3992 result = (int)wxGetOsVersion(arg1,arg2);
3993
3994 wxPyEndAllowThreads(__tstate);
3995 if (PyErr_Occurred()) SWIG_fail;
3996 }
3997 {
3998 resultobj = SWIG_From_int((int)(result));
3999 }
4000 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4001 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4002 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4003 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4004 return resultobj;
4005 fail:
4006 return NULL;
4007 }
4008
4009
4010 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4011 PyObject *resultobj;
4012 wxString result;
4013 char *kwnames[] = {
4014 NULL
4015 };
4016
4017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4018 {
4019 PyThreadState* __tstate = wxPyBeginAllowThreads();
4020 result = wxGetOsDescription();
4021
4022 wxPyEndAllowThreads(__tstate);
4023 if (PyErr_Occurred()) SWIG_fail;
4024 }
4025 {
4026 #if wxUSE_UNICODE
4027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4028 #else
4029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4030 #endif
4031 }
4032 return resultobj;
4033 fail:
4034 return NULL;
4035 }
4036
4037
4038 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4039 PyObject *resultobj;
4040 long result;
4041 char *kwnames[] = {
4042 NULL
4043 };
4044
4045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4046 {
4047 PyThreadState* __tstate = wxPyBeginAllowThreads();
4048 result = (long)wxGetFreeMemory();
4049
4050 wxPyEndAllowThreads(__tstate);
4051 if (PyErr_Occurred()) SWIG_fail;
4052 }
4053 {
4054 resultobj = SWIG_From_long((long)(result));
4055 }
4056 return resultobj;
4057 fail:
4058 return NULL;
4059 }
4060
4061
4062 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4063 PyObject *resultobj;
4064 wxShutdownFlags arg1 ;
4065 bool result;
4066 PyObject * obj0 = 0 ;
4067 char *kwnames[] = {
4068 (char *) "wFlags", NULL
4069 };
4070
4071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4072 {
4073 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4074 if (SWIG_arg_fail(1)) SWIG_fail;
4075 }
4076 {
4077 if (!wxPyCheckForApp()) SWIG_fail;
4078 PyThreadState* __tstate = wxPyBeginAllowThreads();
4079 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4080
4081 wxPyEndAllowThreads(__tstate);
4082 if (PyErr_Occurred()) SWIG_fail;
4083 }
4084 {
4085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4086 }
4087 return resultobj;
4088 fail:
4089 return NULL;
4090 }
4091
4092
4093 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj;
4095 int arg1 ;
4096 PyObject * obj0 = 0 ;
4097 char *kwnames[] = {
4098 (char *) "secs", NULL
4099 };
4100
4101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4102 {
4103 arg1 = (int)(SWIG_As_int(obj0));
4104 if (SWIG_arg_fail(1)) SWIG_fail;
4105 }
4106 {
4107 PyThreadState* __tstate = wxPyBeginAllowThreads();
4108 wxSleep(arg1);
4109
4110 wxPyEndAllowThreads(__tstate);
4111 if (PyErr_Occurred()) SWIG_fail;
4112 }
4113 Py_INCREF(Py_None); resultobj = Py_None;
4114 return resultobj;
4115 fail:
4116 return NULL;
4117 }
4118
4119
4120 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4121 PyObject *resultobj;
4122 unsigned long arg1 ;
4123 PyObject * obj0 = 0 ;
4124 char *kwnames[] = {
4125 (char *) "milliseconds", NULL
4126 };
4127
4128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4129 {
4130 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4131 if (SWIG_arg_fail(1)) SWIG_fail;
4132 }
4133 {
4134 PyThreadState* __tstate = wxPyBeginAllowThreads();
4135 wxMilliSleep(arg1);
4136
4137 wxPyEndAllowThreads(__tstate);
4138 if (PyErr_Occurred()) SWIG_fail;
4139 }
4140 Py_INCREF(Py_None); resultobj = Py_None;
4141 return resultobj;
4142 fail:
4143 return NULL;
4144 }
4145
4146
4147 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4148 PyObject *resultobj;
4149 unsigned long arg1 ;
4150 PyObject * obj0 = 0 ;
4151 char *kwnames[] = {
4152 (char *) "microseconds", NULL
4153 };
4154
4155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4156 {
4157 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4158 if (SWIG_arg_fail(1)) SWIG_fail;
4159 }
4160 {
4161 PyThreadState* __tstate = wxPyBeginAllowThreads();
4162 wxMicroSleep(arg1);
4163
4164 wxPyEndAllowThreads(__tstate);
4165 if (PyErr_Occurred()) SWIG_fail;
4166 }
4167 Py_INCREF(Py_None); resultobj = Py_None;
4168 return resultobj;
4169 fail:
4170 return NULL;
4171 }
4172
4173
4174 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4175 PyObject *resultobj;
4176 bool arg1 ;
4177 PyObject * obj0 = 0 ;
4178 char *kwnames[] = {
4179 (char *) "enable", NULL
4180 };
4181
4182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4183 {
4184 arg1 = (bool)(SWIG_As_bool(obj0));
4185 if (SWIG_arg_fail(1)) SWIG_fail;
4186 }
4187 {
4188 PyThreadState* __tstate = wxPyBeginAllowThreads();
4189 wxEnableTopLevelWindows(arg1);
4190
4191 wxPyEndAllowThreads(__tstate);
4192 if (PyErr_Occurred()) SWIG_fail;
4193 }
4194 Py_INCREF(Py_None); resultobj = Py_None;
4195 return resultobj;
4196 fail:
4197 return NULL;
4198 }
4199
4200
4201 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4202 PyObject *resultobj;
4203 wxString *arg1 = 0 ;
4204 wxString result;
4205 bool temp1 = false ;
4206 PyObject * obj0 = 0 ;
4207 char *kwnames[] = {
4208 (char *) "in", NULL
4209 };
4210
4211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4212 {
4213 arg1 = wxString_in_helper(obj0);
4214 if (arg1 == NULL) SWIG_fail;
4215 temp1 = true;
4216 }
4217 {
4218 PyThreadState* __tstate = wxPyBeginAllowThreads();
4219 result = wxStripMenuCodes((wxString const &)*arg1);
4220
4221 wxPyEndAllowThreads(__tstate);
4222 if (PyErr_Occurred()) SWIG_fail;
4223 }
4224 {
4225 #if wxUSE_UNICODE
4226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4227 #else
4228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4229 #endif
4230 }
4231 {
4232 if (temp1)
4233 delete arg1;
4234 }
4235 return resultobj;
4236 fail:
4237 {
4238 if (temp1)
4239 delete arg1;
4240 }
4241 return NULL;
4242 }
4243
4244
4245 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4246 PyObject *resultobj;
4247 wxString result;
4248 char *kwnames[] = {
4249 NULL
4250 };
4251
4252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4253 {
4254 PyThreadState* __tstate = wxPyBeginAllowThreads();
4255 result = wxGetEmailAddress();
4256
4257 wxPyEndAllowThreads(__tstate);
4258 if (PyErr_Occurred()) SWIG_fail;
4259 }
4260 {
4261 #if wxUSE_UNICODE
4262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4263 #else
4264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4265 #endif
4266 }
4267 return resultobj;
4268 fail:
4269 return NULL;
4270 }
4271
4272
4273 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4274 PyObject *resultobj;
4275 wxString result;
4276 char *kwnames[] = {
4277 NULL
4278 };
4279
4280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4281 {
4282 PyThreadState* __tstate = wxPyBeginAllowThreads();
4283 result = wxGetHostName();
4284
4285 wxPyEndAllowThreads(__tstate);
4286 if (PyErr_Occurred()) SWIG_fail;
4287 }
4288 {
4289 #if wxUSE_UNICODE
4290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4291 #else
4292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4293 #endif
4294 }
4295 return resultobj;
4296 fail:
4297 return NULL;
4298 }
4299
4300
4301 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4302 PyObject *resultobj;
4303 wxString result;
4304 char *kwnames[] = {
4305 NULL
4306 };
4307
4308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4309 {
4310 PyThreadState* __tstate = wxPyBeginAllowThreads();
4311 result = wxGetFullHostName();
4312
4313 wxPyEndAllowThreads(__tstate);
4314 if (PyErr_Occurred()) SWIG_fail;
4315 }
4316 {
4317 #if wxUSE_UNICODE
4318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4319 #else
4320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4321 #endif
4322 }
4323 return resultobj;
4324 fail:
4325 return NULL;
4326 }
4327
4328
4329 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4330 PyObject *resultobj;
4331 wxString result;
4332 char *kwnames[] = {
4333 NULL
4334 };
4335
4336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4337 {
4338 PyThreadState* __tstate = wxPyBeginAllowThreads();
4339 result = wxGetUserId();
4340
4341 wxPyEndAllowThreads(__tstate);
4342 if (PyErr_Occurred()) SWIG_fail;
4343 }
4344 {
4345 #if wxUSE_UNICODE
4346 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4347 #else
4348 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4349 #endif
4350 }
4351 return resultobj;
4352 fail:
4353 return NULL;
4354 }
4355
4356
4357 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4358 PyObject *resultobj;
4359 wxString result;
4360 char *kwnames[] = {
4361 NULL
4362 };
4363
4364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4365 {
4366 PyThreadState* __tstate = wxPyBeginAllowThreads();
4367 result = wxGetUserName();
4368
4369 wxPyEndAllowThreads(__tstate);
4370 if (PyErr_Occurred()) SWIG_fail;
4371 }
4372 {
4373 #if wxUSE_UNICODE
4374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4375 #else
4376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4377 #endif
4378 }
4379 return resultobj;
4380 fail:
4381 return NULL;
4382 }
4383
4384
4385 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4386 PyObject *resultobj;
4387 wxString result;
4388 char *kwnames[] = {
4389 NULL
4390 };
4391
4392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4393 {
4394 PyThreadState* __tstate = wxPyBeginAllowThreads();
4395 result = wxGetHomeDir();
4396
4397 wxPyEndAllowThreads(__tstate);
4398 if (PyErr_Occurred()) SWIG_fail;
4399 }
4400 {
4401 #if wxUSE_UNICODE
4402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4403 #else
4404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4405 #endif
4406 }
4407 return resultobj;
4408 fail:
4409 return NULL;
4410 }
4411
4412
4413 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4414 PyObject *resultobj;
4415 wxString const &arg1_defvalue = wxPyEmptyString ;
4416 wxString *arg1 = (wxString *) &arg1_defvalue ;
4417 wxString result;
4418 bool temp1 = false ;
4419 PyObject * obj0 = 0 ;
4420 char *kwnames[] = {
4421 (char *) "user", NULL
4422 };
4423
4424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4425 if (obj0) {
4426 {
4427 arg1 = wxString_in_helper(obj0);
4428 if (arg1 == NULL) SWIG_fail;
4429 temp1 = true;
4430 }
4431 }
4432 {
4433 PyThreadState* __tstate = wxPyBeginAllowThreads();
4434 result = wxGetUserHome((wxString const &)*arg1);
4435
4436 wxPyEndAllowThreads(__tstate);
4437 if (PyErr_Occurred()) SWIG_fail;
4438 }
4439 {
4440 #if wxUSE_UNICODE
4441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4442 #else
4443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4444 #endif
4445 }
4446 {
4447 if (temp1)
4448 delete arg1;
4449 }
4450 return resultobj;
4451 fail:
4452 {
4453 if (temp1)
4454 delete arg1;
4455 }
4456 return NULL;
4457 }
4458
4459
4460 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4461 PyObject *resultobj;
4462 unsigned long result;
4463 char *kwnames[] = {
4464 NULL
4465 };
4466
4467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4468 {
4469 PyThreadState* __tstate = wxPyBeginAllowThreads();
4470 result = (unsigned long)wxGetProcessId();
4471
4472 wxPyEndAllowThreads(__tstate);
4473 if (PyErr_Occurred()) SWIG_fail;
4474 }
4475 {
4476 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4477 }
4478 return resultobj;
4479 fail:
4480 return NULL;
4481 }
4482
4483
4484 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4485 PyObject *resultobj;
4486 char *kwnames[] = {
4487 NULL
4488 };
4489
4490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4491 {
4492 PyThreadState* __tstate = wxPyBeginAllowThreads();
4493 wxTrap();
4494
4495 wxPyEndAllowThreads(__tstate);
4496 if (PyErr_Occurred()) SWIG_fail;
4497 }
4498 Py_INCREF(Py_None); resultobj = Py_None;
4499 return resultobj;
4500 fail:
4501 return NULL;
4502 }
4503
4504
4505 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4506 PyObject *resultobj;
4507 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4508 wxString *arg1 = (wxString *) &arg1_defvalue ;
4509 wxString const &arg2_defvalue = wxPyEmptyString ;
4510 wxString *arg2 = (wxString *) &arg2_defvalue ;
4511 wxString const &arg3_defvalue = wxPyEmptyString ;
4512 wxString *arg3 = (wxString *) &arg3_defvalue ;
4513 wxString const &arg4_defvalue = wxPyEmptyString ;
4514 wxString *arg4 = (wxString *) &arg4_defvalue ;
4515 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4516 wxString *arg5 = (wxString *) &arg5_defvalue ;
4517 int arg6 = (int) 0 ;
4518 wxWindow *arg7 = (wxWindow *) NULL ;
4519 int arg8 = (int) -1 ;
4520 int arg9 = (int) -1 ;
4521 wxString result;
4522 bool temp1 = false ;
4523 bool temp2 = false ;
4524 bool temp3 = false ;
4525 bool temp4 = false ;
4526 bool temp5 = false ;
4527 PyObject * obj0 = 0 ;
4528 PyObject * obj1 = 0 ;
4529 PyObject * obj2 = 0 ;
4530 PyObject * obj3 = 0 ;
4531 PyObject * obj4 = 0 ;
4532 PyObject * obj5 = 0 ;
4533 PyObject * obj6 = 0 ;
4534 PyObject * obj7 = 0 ;
4535 PyObject * obj8 = 0 ;
4536 char *kwnames[] = {
4537 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4538 };
4539
4540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4541 if (obj0) {
4542 {
4543 arg1 = wxString_in_helper(obj0);
4544 if (arg1 == NULL) SWIG_fail;
4545 temp1 = true;
4546 }
4547 }
4548 if (obj1) {
4549 {
4550 arg2 = wxString_in_helper(obj1);
4551 if (arg2 == NULL) SWIG_fail;
4552 temp2 = true;
4553 }
4554 }
4555 if (obj2) {
4556 {
4557 arg3 = wxString_in_helper(obj2);
4558 if (arg3 == NULL) SWIG_fail;
4559 temp3 = true;
4560 }
4561 }
4562 if (obj3) {
4563 {
4564 arg4 = wxString_in_helper(obj3);
4565 if (arg4 == NULL) SWIG_fail;
4566 temp4 = true;
4567 }
4568 }
4569 if (obj4) {
4570 {
4571 arg5 = wxString_in_helper(obj4);
4572 if (arg5 == NULL) SWIG_fail;
4573 temp5 = true;
4574 }
4575 }
4576 if (obj5) {
4577 {
4578 arg6 = (int)(SWIG_As_int(obj5));
4579 if (SWIG_arg_fail(6)) SWIG_fail;
4580 }
4581 }
4582 if (obj6) {
4583 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4584 if (SWIG_arg_fail(7)) SWIG_fail;
4585 }
4586 if (obj7) {
4587 {
4588 arg8 = (int)(SWIG_As_int(obj7));
4589 if (SWIG_arg_fail(8)) SWIG_fail;
4590 }
4591 }
4592 if (obj8) {
4593 {
4594 arg9 = (int)(SWIG_As_int(obj8));
4595 if (SWIG_arg_fail(9)) SWIG_fail;
4596 }
4597 }
4598 {
4599 if (!wxPyCheckForApp()) SWIG_fail;
4600 PyThreadState* __tstate = wxPyBeginAllowThreads();
4601 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4602
4603 wxPyEndAllowThreads(__tstate);
4604 if (PyErr_Occurred()) SWIG_fail;
4605 }
4606 {
4607 #if wxUSE_UNICODE
4608 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4609 #else
4610 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4611 #endif
4612 }
4613 {
4614 if (temp1)
4615 delete arg1;
4616 }
4617 {
4618 if (temp2)
4619 delete arg2;
4620 }
4621 {
4622 if (temp3)
4623 delete arg3;
4624 }
4625 {
4626 if (temp4)
4627 delete arg4;
4628 }
4629 {
4630 if (temp5)
4631 delete arg5;
4632 }
4633 return resultobj;
4634 fail:
4635 {
4636 if (temp1)
4637 delete arg1;
4638 }
4639 {
4640 if (temp2)
4641 delete arg2;
4642 }
4643 {
4644 if (temp3)
4645 delete arg3;
4646 }
4647 {
4648 if (temp4)
4649 delete arg4;
4650 }
4651 {
4652 if (temp5)
4653 delete arg5;
4654 }
4655 return NULL;
4656 }
4657
4658
4659 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4660 PyObject *resultobj;
4661 wxString *arg1 = 0 ;
4662 wxString *arg2 = 0 ;
4663 wxString const &arg3_defvalue = wxPyEmptyString ;
4664 wxString *arg3 = (wxString *) &arg3_defvalue ;
4665 wxWindow *arg4 = (wxWindow *) NULL ;
4666 wxString result;
4667 bool temp1 = false ;
4668 bool temp2 = false ;
4669 bool temp3 = false ;
4670 PyObject * obj0 = 0 ;
4671 PyObject * obj1 = 0 ;
4672 PyObject * obj2 = 0 ;
4673 PyObject * obj3 = 0 ;
4674 char *kwnames[] = {
4675 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4676 };
4677
4678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4679 {
4680 arg1 = wxString_in_helper(obj0);
4681 if (arg1 == NULL) SWIG_fail;
4682 temp1 = true;
4683 }
4684 {
4685 arg2 = wxString_in_helper(obj1);
4686 if (arg2 == NULL) SWIG_fail;
4687 temp2 = true;
4688 }
4689 if (obj2) {
4690 {
4691 arg3 = wxString_in_helper(obj2);
4692 if (arg3 == NULL) SWIG_fail;
4693 temp3 = true;
4694 }
4695 }
4696 if (obj3) {
4697 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4698 if (SWIG_arg_fail(4)) SWIG_fail;
4699 }
4700 {
4701 if (!wxPyCheckForApp()) SWIG_fail;
4702 PyThreadState* __tstate = wxPyBeginAllowThreads();
4703 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4704
4705 wxPyEndAllowThreads(__tstate);
4706 if (PyErr_Occurred()) SWIG_fail;
4707 }
4708 {
4709 #if wxUSE_UNICODE
4710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4711 #else
4712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4713 #endif
4714 }
4715 {
4716 if (temp1)
4717 delete arg1;
4718 }
4719 {
4720 if (temp2)
4721 delete arg2;
4722 }
4723 {
4724 if (temp3)
4725 delete arg3;
4726 }
4727 return resultobj;
4728 fail:
4729 {
4730 if (temp1)
4731 delete arg1;
4732 }
4733 {
4734 if (temp2)
4735 delete arg2;
4736 }
4737 {
4738 if (temp3)
4739 delete arg3;
4740 }
4741 return NULL;
4742 }
4743
4744
4745 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4746 PyObject *resultobj;
4747 wxString *arg1 = 0 ;
4748 wxString *arg2 = 0 ;
4749 wxString const &arg3_defvalue = wxPyEmptyString ;
4750 wxString *arg3 = (wxString *) &arg3_defvalue ;
4751 wxWindow *arg4 = (wxWindow *) NULL ;
4752 wxString result;
4753 bool temp1 = false ;
4754 bool temp2 = false ;
4755 bool temp3 = false ;
4756 PyObject * obj0 = 0 ;
4757 PyObject * obj1 = 0 ;
4758 PyObject * obj2 = 0 ;
4759 PyObject * obj3 = 0 ;
4760 char *kwnames[] = {
4761 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4762 };
4763
4764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4765 {
4766 arg1 = wxString_in_helper(obj0);
4767 if (arg1 == NULL) SWIG_fail;
4768 temp1 = true;
4769 }
4770 {
4771 arg2 = wxString_in_helper(obj1);
4772 if (arg2 == NULL) SWIG_fail;
4773 temp2 = true;
4774 }
4775 if (obj2) {
4776 {
4777 arg3 = wxString_in_helper(obj2);
4778 if (arg3 == NULL) SWIG_fail;
4779 temp3 = true;
4780 }
4781 }
4782 if (obj3) {
4783 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4784 if (SWIG_arg_fail(4)) SWIG_fail;
4785 }
4786 {
4787 if (!wxPyCheckForApp()) SWIG_fail;
4788 PyThreadState* __tstate = wxPyBeginAllowThreads();
4789 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4790
4791 wxPyEndAllowThreads(__tstate);
4792 if (PyErr_Occurred()) SWIG_fail;
4793 }
4794 {
4795 #if wxUSE_UNICODE
4796 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4797 #else
4798 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4799 #endif
4800 }
4801 {
4802 if (temp1)
4803 delete arg1;
4804 }
4805 {
4806 if (temp2)
4807 delete arg2;
4808 }
4809 {
4810 if (temp3)
4811 delete arg3;
4812 }
4813 return resultobj;
4814 fail:
4815 {
4816 if (temp1)
4817 delete arg1;
4818 }
4819 {
4820 if (temp2)
4821 delete arg2;
4822 }
4823 {
4824 if (temp3)
4825 delete arg3;
4826 }
4827 return NULL;
4828 }
4829
4830
4831 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4832 PyObject *resultobj;
4833 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4834 wxString *arg1 = (wxString *) &arg1_defvalue ;
4835 wxString const &arg2_defvalue = wxPyEmptyString ;
4836 wxString *arg2 = (wxString *) &arg2_defvalue ;
4837 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4838 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4839 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4840 wxWindow *arg5 = (wxWindow *) NULL ;
4841 wxString result;
4842 bool temp1 = false ;
4843 bool temp2 = false ;
4844 wxPoint temp4 ;
4845 PyObject * obj0 = 0 ;
4846 PyObject * obj1 = 0 ;
4847 PyObject * obj2 = 0 ;
4848 PyObject * obj3 = 0 ;
4849 PyObject * obj4 = 0 ;
4850 char *kwnames[] = {
4851 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4852 };
4853
4854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4855 if (obj0) {
4856 {
4857 arg1 = wxString_in_helper(obj0);
4858 if (arg1 == NULL) SWIG_fail;
4859 temp1 = true;
4860 }
4861 }
4862 if (obj1) {
4863 {
4864 arg2 = wxString_in_helper(obj1);
4865 if (arg2 == NULL) SWIG_fail;
4866 temp2 = true;
4867 }
4868 }
4869 if (obj2) {
4870 {
4871 arg3 = (long)(SWIG_As_long(obj2));
4872 if (SWIG_arg_fail(3)) SWIG_fail;
4873 }
4874 }
4875 if (obj3) {
4876 {
4877 arg4 = &temp4;
4878 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4879 }
4880 }
4881 if (obj4) {
4882 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4883 if (SWIG_arg_fail(5)) SWIG_fail;
4884 }
4885 {
4886 if (!wxPyCheckForApp()) SWIG_fail;
4887 PyThreadState* __tstate = wxPyBeginAllowThreads();
4888 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4889
4890 wxPyEndAllowThreads(__tstate);
4891 if (PyErr_Occurred()) SWIG_fail;
4892 }
4893 {
4894 #if wxUSE_UNICODE
4895 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4896 #else
4897 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4898 #endif
4899 }
4900 {
4901 if (temp1)
4902 delete arg1;
4903 }
4904 {
4905 if (temp2)
4906 delete arg2;
4907 }
4908 return resultobj;
4909 fail:
4910 {
4911 if (temp1)
4912 delete arg1;
4913 }
4914 {
4915 if (temp2)
4916 delete arg2;
4917 }
4918 return NULL;
4919 }
4920
4921
4922 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4923 PyObject *resultobj;
4924 wxString *arg1 = 0 ;
4925 wxString const &arg2_defvalue = wxPyEmptyString ;
4926 wxString *arg2 = (wxString *) &arg2_defvalue ;
4927 wxString const &arg3_defvalue = wxPyEmptyString ;
4928 wxString *arg3 = (wxString *) &arg3_defvalue ;
4929 wxWindow *arg4 = (wxWindow *) NULL ;
4930 int arg5 = (int) -1 ;
4931 int arg6 = (int) -1 ;
4932 bool arg7 = (bool) true ;
4933 wxString result;
4934 bool temp1 = false ;
4935 bool temp2 = false ;
4936 bool temp3 = false ;
4937 PyObject * obj0 = 0 ;
4938 PyObject * obj1 = 0 ;
4939 PyObject * obj2 = 0 ;
4940 PyObject * obj3 = 0 ;
4941 PyObject * obj4 = 0 ;
4942 PyObject * obj5 = 0 ;
4943 PyObject * obj6 = 0 ;
4944 char *kwnames[] = {
4945 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4946 };
4947
4948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4949 {
4950 arg1 = wxString_in_helper(obj0);
4951 if (arg1 == NULL) SWIG_fail;
4952 temp1 = true;
4953 }
4954 if (obj1) {
4955 {
4956 arg2 = wxString_in_helper(obj1);
4957 if (arg2 == NULL) SWIG_fail;
4958 temp2 = true;
4959 }
4960 }
4961 if (obj2) {
4962 {
4963 arg3 = wxString_in_helper(obj2);
4964 if (arg3 == NULL) SWIG_fail;
4965 temp3 = true;
4966 }
4967 }
4968 if (obj3) {
4969 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4970 if (SWIG_arg_fail(4)) SWIG_fail;
4971 }
4972 if (obj4) {
4973 {
4974 arg5 = (int)(SWIG_As_int(obj4));
4975 if (SWIG_arg_fail(5)) SWIG_fail;
4976 }
4977 }
4978 if (obj5) {
4979 {
4980 arg6 = (int)(SWIG_As_int(obj5));
4981 if (SWIG_arg_fail(6)) SWIG_fail;
4982 }
4983 }
4984 if (obj6) {
4985 {
4986 arg7 = (bool)(SWIG_As_bool(obj6));
4987 if (SWIG_arg_fail(7)) SWIG_fail;
4988 }
4989 }
4990 {
4991 if (!wxPyCheckForApp()) SWIG_fail;
4992 PyThreadState* __tstate = wxPyBeginAllowThreads();
4993 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4994
4995 wxPyEndAllowThreads(__tstate);
4996 if (PyErr_Occurred()) SWIG_fail;
4997 }
4998 {
4999 #if wxUSE_UNICODE
5000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5001 #else
5002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5003 #endif
5004 }
5005 {
5006 if (temp1)
5007 delete arg1;
5008 }
5009 {
5010 if (temp2)
5011 delete arg2;
5012 }
5013 {
5014 if (temp3)
5015 delete arg3;
5016 }
5017 return resultobj;
5018 fail:
5019 {
5020 if (temp1)
5021 delete arg1;
5022 }
5023 {
5024 if (temp2)
5025 delete arg2;
5026 }
5027 {
5028 if (temp3)
5029 delete arg3;
5030 }
5031 return NULL;
5032 }
5033
5034
5035 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5036 PyObject *resultobj;
5037 wxString *arg1 = 0 ;
5038 wxString const &arg2_defvalue = wxPyEmptyString ;
5039 wxString *arg2 = (wxString *) &arg2_defvalue ;
5040 wxString const &arg3_defvalue = wxPyEmptyString ;
5041 wxString *arg3 = (wxString *) &arg3_defvalue ;
5042 wxWindow *arg4 = (wxWindow *) NULL ;
5043 wxString result;
5044 bool temp1 = false ;
5045 bool temp2 = false ;
5046 bool temp3 = false ;
5047 PyObject * obj0 = 0 ;
5048 PyObject * obj1 = 0 ;
5049 PyObject * obj2 = 0 ;
5050 PyObject * obj3 = 0 ;
5051 char *kwnames[] = {
5052 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5053 };
5054
5055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5056 {
5057 arg1 = wxString_in_helper(obj0);
5058 if (arg1 == NULL) SWIG_fail;
5059 temp1 = true;
5060 }
5061 if (obj1) {
5062 {
5063 arg2 = wxString_in_helper(obj1);
5064 if (arg2 == NULL) SWIG_fail;
5065 temp2 = true;
5066 }
5067 }
5068 if (obj2) {
5069 {
5070 arg3 = wxString_in_helper(obj2);
5071 if (arg3 == NULL) SWIG_fail;
5072 temp3 = true;
5073 }
5074 }
5075 if (obj3) {
5076 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5077 if (SWIG_arg_fail(4)) SWIG_fail;
5078 }
5079 {
5080 if (!wxPyCheckForApp()) SWIG_fail;
5081 PyThreadState* __tstate = wxPyBeginAllowThreads();
5082 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5083
5084 wxPyEndAllowThreads(__tstate);
5085 if (PyErr_Occurred()) SWIG_fail;
5086 }
5087 {
5088 #if wxUSE_UNICODE
5089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5090 #else
5091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5092 #endif
5093 }
5094 {
5095 if (temp1)
5096 delete arg1;
5097 }
5098 {
5099 if (temp2)
5100 delete arg2;
5101 }
5102 {
5103 if (temp3)
5104 delete arg3;
5105 }
5106 return resultobj;
5107 fail:
5108 {
5109 if (temp1)
5110 delete arg1;
5111 }
5112 {
5113 if (temp2)
5114 delete arg2;
5115 }
5116 {
5117 if (temp3)
5118 delete arg3;
5119 }
5120 return NULL;
5121 }
5122
5123
5124 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5125 PyObject *resultobj;
5126 wxString *arg1 = 0 ;
5127 wxString *arg2 = 0 ;
5128 int arg3 ;
5129 wxString *arg4 = (wxString *) 0 ;
5130 wxWindow *arg5 = (wxWindow *) NULL ;
5131 int arg6 = (int) -1 ;
5132 int arg7 = (int) -1 ;
5133 bool arg8 = (bool) true ;
5134 int arg9 = (int) 150 ;
5135 int arg10 = (int) 200 ;
5136 wxString result;
5137 bool temp1 = false ;
5138 bool temp2 = false ;
5139 PyObject * obj0 = 0 ;
5140 PyObject * obj1 = 0 ;
5141 PyObject * obj2 = 0 ;
5142 PyObject * obj3 = 0 ;
5143 PyObject * obj4 = 0 ;
5144 PyObject * obj5 = 0 ;
5145 PyObject * obj6 = 0 ;
5146 PyObject * obj7 = 0 ;
5147 PyObject * obj8 = 0 ;
5148 char *kwnames[] = {
5149 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5150 };
5151
5152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5153 {
5154 arg1 = wxString_in_helper(obj0);
5155 if (arg1 == NULL) SWIG_fail;
5156 temp1 = true;
5157 }
5158 {
5159 arg2 = wxString_in_helper(obj1);
5160 if (arg2 == NULL) SWIG_fail;
5161 temp2 = true;
5162 }
5163 {
5164 arg3 = PyList_Size(obj2);
5165 arg4 = wxString_LIST_helper(obj2);
5166 if (arg4 == NULL) SWIG_fail;
5167 }
5168 if (obj3) {
5169 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5170 if (SWIG_arg_fail(5)) SWIG_fail;
5171 }
5172 if (obj4) {
5173 {
5174 arg6 = (int)(SWIG_As_int(obj4));
5175 if (SWIG_arg_fail(6)) SWIG_fail;
5176 }
5177 }
5178 if (obj5) {
5179 {
5180 arg7 = (int)(SWIG_As_int(obj5));
5181 if (SWIG_arg_fail(7)) SWIG_fail;
5182 }
5183 }
5184 if (obj6) {
5185 {
5186 arg8 = (bool)(SWIG_As_bool(obj6));
5187 if (SWIG_arg_fail(8)) SWIG_fail;
5188 }
5189 }
5190 if (obj7) {
5191 {
5192 arg9 = (int)(SWIG_As_int(obj7));
5193 if (SWIG_arg_fail(9)) SWIG_fail;
5194 }
5195 }
5196 if (obj8) {
5197 {
5198 arg10 = (int)(SWIG_As_int(obj8));
5199 if (SWIG_arg_fail(10)) SWIG_fail;
5200 }
5201 }
5202 {
5203 if (!wxPyCheckForApp()) SWIG_fail;
5204 PyThreadState* __tstate = wxPyBeginAllowThreads();
5205 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5206
5207 wxPyEndAllowThreads(__tstate);
5208 if (PyErr_Occurred()) SWIG_fail;
5209 }
5210 {
5211 #if wxUSE_UNICODE
5212 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5213 #else
5214 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5215 #endif
5216 }
5217 {
5218 if (temp1)
5219 delete arg1;
5220 }
5221 {
5222 if (temp2)
5223 delete arg2;
5224 }
5225 {
5226 if (arg4) delete [] arg4;
5227 }
5228 return resultobj;
5229 fail:
5230 {
5231 if (temp1)
5232 delete arg1;
5233 }
5234 {
5235 if (temp2)
5236 delete arg2;
5237 }
5238 {
5239 if (arg4) delete [] arg4;
5240 }
5241 return NULL;
5242 }
5243
5244
5245 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5246 PyObject *resultobj;
5247 wxString *arg1 = 0 ;
5248 wxString *arg2 = 0 ;
5249 int arg3 ;
5250 wxString *arg4 = (wxString *) 0 ;
5251 wxWindow *arg5 = (wxWindow *) NULL ;
5252 int arg6 = (int) -1 ;
5253 int arg7 = (int) -1 ;
5254 bool arg8 = (bool) true ;
5255 int arg9 = (int) 150 ;
5256 int arg10 = (int) 200 ;
5257 int result;
5258 bool temp1 = false ;
5259 bool temp2 = false ;
5260 PyObject * obj0 = 0 ;
5261 PyObject * obj1 = 0 ;
5262 PyObject * obj2 = 0 ;
5263 PyObject * obj3 = 0 ;
5264 PyObject * obj4 = 0 ;
5265 PyObject * obj5 = 0 ;
5266 PyObject * obj6 = 0 ;
5267 PyObject * obj7 = 0 ;
5268 PyObject * obj8 = 0 ;
5269 char *kwnames[] = {
5270 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5271 };
5272
5273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5274 {
5275 arg1 = wxString_in_helper(obj0);
5276 if (arg1 == NULL) SWIG_fail;
5277 temp1 = true;
5278 }
5279 {
5280 arg2 = wxString_in_helper(obj1);
5281 if (arg2 == NULL) SWIG_fail;
5282 temp2 = true;
5283 }
5284 {
5285 arg3 = PyList_Size(obj2);
5286 arg4 = wxString_LIST_helper(obj2);
5287 if (arg4 == NULL) SWIG_fail;
5288 }
5289 if (obj3) {
5290 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5291 if (SWIG_arg_fail(5)) SWIG_fail;
5292 }
5293 if (obj4) {
5294 {
5295 arg6 = (int)(SWIG_As_int(obj4));
5296 if (SWIG_arg_fail(6)) SWIG_fail;
5297 }
5298 }
5299 if (obj5) {
5300 {
5301 arg7 = (int)(SWIG_As_int(obj5));
5302 if (SWIG_arg_fail(7)) SWIG_fail;
5303 }
5304 }
5305 if (obj6) {
5306 {
5307 arg8 = (bool)(SWIG_As_bool(obj6));
5308 if (SWIG_arg_fail(8)) SWIG_fail;
5309 }
5310 }
5311 if (obj7) {
5312 {
5313 arg9 = (int)(SWIG_As_int(obj7));
5314 if (SWIG_arg_fail(9)) SWIG_fail;
5315 }
5316 }
5317 if (obj8) {
5318 {
5319 arg10 = (int)(SWIG_As_int(obj8));
5320 if (SWIG_arg_fail(10)) SWIG_fail;
5321 }
5322 }
5323 {
5324 if (!wxPyCheckForApp()) SWIG_fail;
5325 PyThreadState* __tstate = wxPyBeginAllowThreads();
5326 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5327
5328 wxPyEndAllowThreads(__tstate);
5329 if (PyErr_Occurred()) SWIG_fail;
5330 }
5331 {
5332 resultobj = SWIG_From_int((int)(result));
5333 }
5334 {
5335 if (temp1)
5336 delete arg1;
5337 }
5338 {
5339 if (temp2)
5340 delete arg2;
5341 }
5342 {
5343 if (arg4) delete [] arg4;
5344 }
5345 return resultobj;
5346 fail:
5347 {
5348 if (temp1)
5349 delete arg1;
5350 }
5351 {
5352 if (temp2)
5353 delete arg2;
5354 }
5355 {
5356 if (arg4) delete [] arg4;
5357 }
5358 return NULL;
5359 }
5360
5361
5362 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5363 PyObject *resultobj;
5364 wxString *arg1 = 0 ;
5365 wxString const &arg2_defvalue = wxPyEmptyString ;
5366 wxString *arg2 = (wxString *) &arg2_defvalue ;
5367 int arg3 = (int) wxOK|wxCENTRE ;
5368 wxWindow *arg4 = (wxWindow *) NULL ;
5369 int arg5 = (int) -1 ;
5370 int arg6 = (int) -1 ;
5371 int result;
5372 bool temp1 = false ;
5373 bool temp2 = false ;
5374 PyObject * obj0 = 0 ;
5375 PyObject * obj1 = 0 ;
5376 PyObject * obj2 = 0 ;
5377 PyObject * obj3 = 0 ;
5378 PyObject * obj4 = 0 ;
5379 PyObject * obj5 = 0 ;
5380 char *kwnames[] = {
5381 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5382 };
5383
5384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5385 {
5386 arg1 = wxString_in_helper(obj0);
5387 if (arg1 == NULL) SWIG_fail;
5388 temp1 = true;
5389 }
5390 if (obj1) {
5391 {
5392 arg2 = wxString_in_helper(obj1);
5393 if (arg2 == NULL) SWIG_fail;
5394 temp2 = true;
5395 }
5396 }
5397 if (obj2) {
5398 {
5399 arg3 = (int)(SWIG_As_int(obj2));
5400 if (SWIG_arg_fail(3)) SWIG_fail;
5401 }
5402 }
5403 if (obj3) {
5404 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5405 if (SWIG_arg_fail(4)) SWIG_fail;
5406 }
5407 if (obj4) {
5408 {
5409 arg5 = (int)(SWIG_As_int(obj4));
5410 if (SWIG_arg_fail(5)) SWIG_fail;
5411 }
5412 }
5413 if (obj5) {
5414 {
5415 arg6 = (int)(SWIG_As_int(obj5));
5416 if (SWIG_arg_fail(6)) SWIG_fail;
5417 }
5418 }
5419 {
5420 if (!wxPyCheckForApp()) SWIG_fail;
5421 PyThreadState* __tstate = wxPyBeginAllowThreads();
5422 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5423
5424 wxPyEndAllowThreads(__tstate);
5425 if (PyErr_Occurred()) SWIG_fail;
5426 }
5427 {
5428 resultobj = SWIG_From_int((int)(result));
5429 }
5430 {
5431 if (temp1)
5432 delete arg1;
5433 }
5434 {
5435 if (temp2)
5436 delete arg2;
5437 }
5438 return resultobj;
5439 fail:
5440 {
5441 if (temp1)
5442 delete arg1;
5443 }
5444 {
5445 if (temp2)
5446 delete arg2;
5447 }
5448 return NULL;
5449 }
5450
5451
5452 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5453 PyObject *resultobj;
5454 wxString *arg1 = 0 ;
5455 wxString *arg2 = 0 ;
5456 wxString *arg3 = 0 ;
5457 long arg4 ;
5458 long arg5 = (long) 0 ;
5459 long arg6 = (long) 100 ;
5460 wxWindow *arg7 = (wxWindow *) NULL ;
5461 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5462 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5463 long result;
5464 bool temp1 = false ;
5465 bool temp2 = false ;
5466 bool temp3 = false ;
5467 wxPoint temp8 ;
5468 PyObject * obj0 = 0 ;
5469 PyObject * obj1 = 0 ;
5470 PyObject * obj2 = 0 ;
5471 PyObject * obj3 = 0 ;
5472 PyObject * obj4 = 0 ;
5473 PyObject * obj5 = 0 ;
5474 PyObject * obj6 = 0 ;
5475 PyObject * obj7 = 0 ;
5476 char *kwnames[] = {
5477 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5478 };
5479
5480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5481 {
5482 arg1 = wxString_in_helper(obj0);
5483 if (arg1 == NULL) SWIG_fail;
5484 temp1 = true;
5485 }
5486 {
5487 arg2 = wxString_in_helper(obj1);
5488 if (arg2 == NULL) SWIG_fail;
5489 temp2 = true;
5490 }
5491 {
5492 arg3 = wxString_in_helper(obj2);
5493 if (arg3 == NULL) SWIG_fail;
5494 temp3 = true;
5495 }
5496 {
5497 arg4 = (long)(SWIG_As_long(obj3));
5498 if (SWIG_arg_fail(4)) SWIG_fail;
5499 }
5500 if (obj4) {
5501 {
5502 arg5 = (long)(SWIG_As_long(obj4));
5503 if (SWIG_arg_fail(5)) SWIG_fail;
5504 }
5505 }
5506 if (obj5) {
5507 {
5508 arg6 = (long)(SWIG_As_long(obj5));
5509 if (SWIG_arg_fail(6)) SWIG_fail;
5510 }
5511 }
5512 if (obj6) {
5513 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5514 if (SWIG_arg_fail(7)) SWIG_fail;
5515 }
5516 if (obj7) {
5517 {
5518 arg8 = &temp8;
5519 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5520 }
5521 }
5522 {
5523 if (!wxPyCheckForApp()) SWIG_fail;
5524 PyThreadState* __tstate = wxPyBeginAllowThreads();
5525 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5526
5527 wxPyEndAllowThreads(__tstate);
5528 if (PyErr_Occurred()) SWIG_fail;
5529 }
5530 {
5531 resultobj = SWIG_From_long((long)(result));
5532 }
5533 {
5534 if (temp1)
5535 delete arg1;
5536 }
5537 {
5538 if (temp2)
5539 delete arg2;
5540 }
5541 {
5542 if (temp3)
5543 delete arg3;
5544 }
5545 return resultobj;
5546 fail:
5547 {
5548 if (temp1)
5549 delete arg1;
5550 }
5551 {
5552 if (temp2)
5553 delete arg2;
5554 }
5555 {
5556 if (temp3)
5557 delete arg3;
5558 }
5559 return NULL;
5560 }
5561
5562
5563 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5564 PyObject *resultobj;
5565 bool result;
5566 char *kwnames[] = {
5567 NULL
5568 };
5569
5570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5571 {
5572 if (!wxPyCheckForApp()) SWIG_fail;
5573 PyThreadState* __tstate = wxPyBeginAllowThreads();
5574 result = (bool)wxColourDisplay();
5575
5576 wxPyEndAllowThreads(__tstate);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj;
5590 int result;
5591 char *kwnames[] = {
5592 NULL
5593 };
5594
5595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5596 {
5597 if (!wxPyCheckForApp()) SWIG_fail;
5598 PyThreadState* __tstate = wxPyBeginAllowThreads();
5599 result = (int)wxDisplayDepth();
5600
5601 wxPyEndAllowThreads(__tstate);
5602 if (PyErr_Occurred()) SWIG_fail;
5603 }
5604 {
5605 resultobj = SWIG_From_int((int)(result));
5606 }
5607 return resultobj;
5608 fail:
5609 return NULL;
5610 }
5611
5612
5613 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5614 PyObject *resultobj;
5615 int result;
5616 char *kwnames[] = {
5617 NULL
5618 };
5619
5620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5621 {
5622 if (!wxPyCheckForApp()) SWIG_fail;
5623 PyThreadState* __tstate = wxPyBeginAllowThreads();
5624 result = (int)wxGetDisplayDepth();
5625
5626 wxPyEndAllowThreads(__tstate);
5627 if (PyErr_Occurred()) SWIG_fail;
5628 }
5629 {
5630 resultobj = SWIG_From_int((int)(result));
5631 }
5632 return resultobj;
5633 fail:
5634 return NULL;
5635 }
5636
5637
5638 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5639 PyObject *resultobj;
5640 int *arg1 = (int *) 0 ;
5641 int *arg2 = (int *) 0 ;
5642 int temp1 ;
5643 int res1 = 0 ;
5644 int temp2 ;
5645 int res2 = 0 ;
5646 char *kwnames[] = {
5647 NULL
5648 };
5649
5650 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5651 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5653 {
5654 if (!wxPyCheckForApp()) SWIG_fail;
5655 PyThreadState* __tstate = wxPyBeginAllowThreads();
5656 wxDisplaySize(arg1,arg2);
5657
5658 wxPyEndAllowThreads(__tstate);
5659 if (PyErr_Occurred()) SWIG_fail;
5660 }
5661 Py_INCREF(Py_None); resultobj = Py_None;
5662 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5663 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5664 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5665 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5666 return resultobj;
5667 fail:
5668 return NULL;
5669 }
5670
5671
5672 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5673 PyObject *resultobj;
5674 wxSize result;
5675 char *kwnames[] = {
5676 NULL
5677 };
5678
5679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5680 {
5681 if (!wxPyCheckForApp()) SWIG_fail;
5682 PyThreadState* __tstate = wxPyBeginAllowThreads();
5683 result = wxGetDisplaySize();
5684
5685 wxPyEndAllowThreads(__tstate);
5686 if (PyErr_Occurred()) SWIG_fail;
5687 }
5688 {
5689 wxSize * resultptr;
5690 resultptr = new wxSize((wxSize &)(result));
5691 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5692 }
5693 return resultobj;
5694 fail:
5695 return NULL;
5696 }
5697
5698
5699 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5700 PyObject *resultobj;
5701 int *arg1 = (int *) 0 ;
5702 int *arg2 = (int *) 0 ;
5703 int temp1 ;
5704 int res1 = 0 ;
5705 int temp2 ;
5706 int res2 = 0 ;
5707 char *kwnames[] = {
5708 NULL
5709 };
5710
5711 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5712 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5714 {
5715 if (!wxPyCheckForApp()) SWIG_fail;
5716 PyThreadState* __tstate = wxPyBeginAllowThreads();
5717 wxDisplaySizeMM(arg1,arg2);
5718
5719 wxPyEndAllowThreads(__tstate);
5720 if (PyErr_Occurred()) SWIG_fail;
5721 }
5722 Py_INCREF(Py_None); resultobj = Py_None;
5723 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5724 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5725 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5726 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5727 return resultobj;
5728 fail:
5729 return NULL;
5730 }
5731
5732
5733 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5734 PyObject *resultobj;
5735 wxSize result;
5736 char *kwnames[] = {
5737 NULL
5738 };
5739
5740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5741 {
5742 if (!wxPyCheckForApp()) SWIG_fail;
5743 PyThreadState* __tstate = wxPyBeginAllowThreads();
5744 result = wxGetDisplaySizeMM();
5745
5746 wxPyEndAllowThreads(__tstate);
5747 if (PyErr_Occurred()) SWIG_fail;
5748 }
5749 {
5750 wxSize * resultptr;
5751 resultptr = new wxSize((wxSize &)(result));
5752 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5753 }
5754 return resultobj;
5755 fail:
5756 return NULL;
5757 }
5758
5759
5760 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5761 PyObject *resultobj;
5762 int *arg1 = (int *) 0 ;
5763 int *arg2 = (int *) 0 ;
5764 int *arg3 = (int *) 0 ;
5765 int *arg4 = (int *) 0 ;
5766 int temp1 ;
5767 int res1 = 0 ;
5768 int temp2 ;
5769 int res2 = 0 ;
5770 int temp3 ;
5771 int res3 = 0 ;
5772 int temp4 ;
5773 int res4 = 0 ;
5774 char *kwnames[] = {
5775 NULL
5776 };
5777
5778 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5779 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5780 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5781 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5783 {
5784 if (!wxPyCheckForApp()) SWIG_fail;
5785 PyThreadState* __tstate = wxPyBeginAllowThreads();
5786 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5787
5788 wxPyEndAllowThreads(__tstate);
5789 if (PyErr_Occurred()) SWIG_fail;
5790 }
5791 Py_INCREF(Py_None); resultobj = Py_None;
5792 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5793 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5794 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5795 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5796 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5797 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5798 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5799 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5800 return resultobj;
5801 fail:
5802 return NULL;
5803 }
5804
5805
5806 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5807 PyObject *resultobj;
5808 wxRect result;
5809 char *kwnames[] = {
5810 NULL
5811 };
5812
5813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5814 {
5815 if (!wxPyCheckForApp()) SWIG_fail;
5816 PyThreadState* __tstate = wxPyBeginAllowThreads();
5817 result = wxGetClientDisplayRect();
5818
5819 wxPyEndAllowThreads(__tstate);
5820 if (PyErr_Occurred()) SWIG_fail;
5821 }
5822 {
5823 wxRect * resultptr;
5824 resultptr = new wxRect((wxRect &)(result));
5825 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5826 }
5827 return resultobj;
5828 fail:
5829 return NULL;
5830 }
5831
5832
5833 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5834 PyObject *resultobj;
5835 wxCursor *arg1 = 0 ;
5836 PyObject * obj0 = 0 ;
5837 char *kwnames[] = {
5838 (char *) "cursor", NULL
5839 };
5840
5841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5842 {
5843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5844 if (SWIG_arg_fail(1)) SWIG_fail;
5845 if (arg1 == NULL) {
5846 SWIG_null_ref("wxCursor");
5847 }
5848 if (SWIG_arg_fail(1)) SWIG_fail;
5849 }
5850 {
5851 if (!wxPyCheckForApp()) SWIG_fail;
5852 PyThreadState* __tstate = wxPyBeginAllowThreads();
5853 wxSetCursor(*arg1);
5854
5855 wxPyEndAllowThreads(__tstate);
5856 if (PyErr_Occurred()) SWIG_fail;
5857 }
5858 Py_INCREF(Py_None); resultobj = Py_None;
5859 return resultobj;
5860 fail:
5861 return NULL;
5862 }
5863
5864
5865 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj;
5867 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5868 PyObject * obj0 = 0 ;
5869 char *kwnames[] = {
5870 (char *) "cursor", NULL
5871 };
5872
5873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5874 if (obj0) {
5875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5876 if (SWIG_arg_fail(1)) SWIG_fail;
5877 }
5878 {
5879 if (!wxPyCheckForApp()) SWIG_fail;
5880 PyThreadState* __tstate = wxPyBeginAllowThreads();
5881 wxBeginBusyCursor(arg1);
5882
5883 wxPyEndAllowThreads(__tstate);
5884 if (PyErr_Occurred()) SWIG_fail;
5885 }
5886 Py_INCREF(Py_None); resultobj = Py_None;
5887 return resultobj;
5888 fail:
5889 return NULL;
5890 }
5891
5892
5893 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5894 PyObject *resultobj;
5895 wxWindow *result;
5896 char *kwnames[] = {
5897 NULL
5898 };
5899
5900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5901 {
5902 if (!wxPyCheckForApp()) SWIG_fail;
5903 PyThreadState* __tstate = wxPyBeginAllowThreads();
5904 result = (wxWindow *)wxGetActiveWindow();
5905
5906 wxPyEndAllowThreads(__tstate);
5907 if (PyErr_Occurred()) SWIG_fail;
5908 }
5909 {
5910 resultobj = wxPyMake_wxObject(result, 0);
5911 }
5912 return resultobj;
5913 fail:
5914 return NULL;
5915 }
5916
5917
5918 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5919 PyObject *resultobj;
5920 wxPoint *arg1 = 0 ;
5921 wxWindow *result;
5922 wxPoint temp1 ;
5923 PyObject * obj0 = 0 ;
5924 char *kwnames[] = {
5925 (char *) "pt", NULL
5926 };
5927
5928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5929 {
5930 arg1 = &temp1;
5931 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5932 }
5933 {
5934 if (!wxPyCheckForApp()) SWIG_fail;
5935 PyThreadState* __tstate = wxPyBeginAllowThreads();
5936 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5937
5938 wxPyEndAllowThreads(__tstate);
5939 if (PyErr_Occurred()) SWIG_fail;
5940 }
5941 {
5942 resultobj = wxPyMake_wxObject(result, 0);
5943 }
5944 return resultobj;
5945 fail:
5946 return NULL;
5947 }
5948
5949
5950 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5951 PyObject *resultobj;
5952 wxPoint *arg1 = 0 ;
5953 wxWindow *result;
5954 wxPoint temp1 ;
5955 PyObject * obj0 = 0 ;
5956 char *kwnames[] = {
5957 (char *) "pt", NULL
5958 };
5959
5960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5961 {
5962 arg1 = &temp1;
5963 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5964 }
5965 {
5966 if (!wxPyCheckForApp()) SWIG_fail;
5967 PyThreadState* __tstate = wxPyBeginAllowThreads();
5968 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5969
5970 wxPyEndAllowThreads(__tstate);
5971 if (PyErr_Occurred()) SWIG_fail;
5972 }
5973 {
5974 resultobj = wxPyMake_wxObject(result, 0);
5975 }
5976 return resultobj;
5977 fail:
5978 return NULL;
5979 }
5980
5981
5982 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5983 PyObject *resultobj;
5984 wxWindow *arg1 = (wxWindow *) 0 ;
5985 wxWindow *result;
5986 PyObject * obj0 = 0 ;
5987 char *kwnames[] = {
5988 (char *) "win", NULL
5989 };
5990
5991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5993 if (SWIG_arg_fail(1)) SWIG_fail;
5994 {
5995 if (!wxPyCheckForApp()) SWIG_fail;
5996 PyThreadState* __tstate = wxPyBeginAllowThreads();
5997 result = (wxWindow *)wxGetTopLevelParent(arg1);
5998
5999 wxPyEndAllowThreads(__tstate);
6000 if (PyErr_Occurred()) SWIG_fail;
6001 }
6002 {
6003 resultobj = wxPyMake_wxObject(result, 0);
6004 }
6005 return resultobj;
6006 fail:
6007 return NULL;
6008 }
6009
6010
6011 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6012 PyObject *resultobj;
6013 wxKeyCode arg1 ;
6014 bool result;
6015 PyObject * obj0 = 0 ;
6016 char *kwnames[] = {
6017 (char *) "key", NULL
6018 };
6019
6020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6021 {
6022 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6023 if (SWIG_arg_fail(1)) SWIG_fail;
6024 }
6025 {
6026 if (!wxPyCheckForApp()) SWIG_fail;
6027 PyThreadState* __tstate = wxPyBeginAllowThreads();
6028 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6029
6030 wxPyEndAllowThreads(__tstate);
6031 if (PyErr_Occurred()) SWIG_fail;
6032 }
6033 {
6034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6035 }
6036 return resultobj;
6037 fail:
6038 return NULL;
6039 }
6040
6041
6042 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6043 PyObject *resultobj;
6044 char *kwnames[] = {
6045 NULL
6046 };
6047
6048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6049 {
6050 if (!wxPyCheckForApp()) SWIG_fail;
6051 PyThreadState* __tstate = wxPyBeginAllowThreads();
6052 wxWakeUpMainThread();
6053
6054 wxPyEndAllowThreads(__tstate);
6055 if (PyErr_Occurred()) SWIG_fail;
6056 }
6057 Py_INCREF(Py_None); resultobj = Py_None;
6058 return resultobj;
6059 fail:
6060 return NULL;
6061 }
6062
6063
6064 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6065 PyObject *resultobj;
6066 char *kwnames[] = {
6067 NULL
6068 };
6069
6070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6071 {
6072 if (!wxPyCheckForApp()) SWIG_fail;
6073 PyThreadState* __tstate = wxPyBeginAllowThreads();
6074 wxMutexGuiEnter();
6075
6076 wxPyEndAllowThreads(__tstate);
6077 if (PyErr_Occurred()) SWIG_fail;
6078 }
6079 Py_INCREF(Py_None); resultobj = Py_None;
6080 return resultobj;
6081 fail:
6082 return NULL;
6083 }
6084
6085
6086 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6087 PyObject *resultobj;
6088 char *kwnames[] = {
6089 NULL
6090 };
6091
6092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6093 {
6094 if (!wxPyCheckForApp()) SWIG_fail;
6095 PyThreadState* __tstate = wxPyBeginAllowThreads();
6096 wxMutexGuiLeave();
6097
6098 wxPyEndAllowThreads(__tstate);
6099 if (PyErr_Occurred()) SWIG_fail;
6100 }
6101 Py_INCREF(Py_None); resultobj = Py_None;
6102 return resultobj;
6103 fail:
6104 return NULL;
6105 }
6106
6107
6108 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6109 PyObject *resultobj;
6110 wxMutexGuiLocker *result;
6111 char *kwnames[] = {
6112 NULL
6113 };
6114
6115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6116 {
6117 if (!wxPyCheckForApp()) SWIG_fail;
6118 PyThreadState* __tstate = wxPyBeginAllowThreads();
6119 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6120
6121 wxPyEndAllowThreads(__tstate);
6122 if (PyErr_Occurred()) SWIG_fail;
6123 }
6124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6125 return resultobj;
6126 fail:
6127 return NULL;
6128 }
6129
6130
6131 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6132 PyObject *resultobj;
6133 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6134 PyObject * obj0 = 0 ;
6135 char *kwnames[] = {
6136 (char *) "self", NULL
6137 };
6138
6139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6141 if (SWIG_arg_fail(1)) SWIG_fail;
6142 {
6143 PyThreadState* __tstate = wxPyBeginAllowThreads();
6144 delete arg1;
6145
6146 wxPyEndAllowThreads(__tstate);
6147 if (PyErr_Occurred()) SWIG_fail;
6148 }
6149 Py_INCREF(Py_None); resultobj = Py_None;
6150 return resultobj;
6151 fail:
6152 return NULL;
6153 }
6154
6155
6156 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6157 PyObject *obj;
6158 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6159 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6160 Py_INCREF(obj);
6161 return Py_BuildValue((char *)"");
6162 }
6163 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6164 PyObject *resultobj;
6165 bool result;
6166 char *kwnames[] = {
6167 NULL
6168 };
6169
6170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6171 {
6172 PyThreadState* __tstate = wxPyBeginAllowThreads();
6173 result = (bool)wxThread_IsMain();
6174
6175 wxPyEndAllowThreads(__tstate);
6176 if (PyErr_Occurred()) SWIG_fail;
6177 }
6178 {
6179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6180 }
6181 return resultobj;
6182 fail:
6183 return NULL;
6184 }
6185
6186
6187 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6188 PyObject *resultobj;
6189 wxString *arg1 = 0 ;
6190 wxToolTip *result;
6191 bool temp1 = false ;
6192 PyObject * obj0 = 0 ;
6193 char *kwnames[] = {
6194 (char *) "tip", NULL
6195 };
6196
6197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6198 {
6199 arg1 = wxString_in_helper(obj0);
6200 if (arg1 == NULL) SWIG_fail;
6201 temp1 = true;
6202 }
6203 {
6204 if (!wxPyCheckForApp()) SWIG_fail;
6205 PyThreadState* __tstate = wxPyBeginAllowThreads();
6206 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6207
6208 wxPyEndAllowThreads(__tstate);
6209 if (PyErr_Occurred()) SWIG_fail;
6210 }
6211 {
6212 resultobj = wxPyMake_wxObject(result, 1);
6213 }
6214 {
6215 if (temp1)
6216 delete arg1;
6217 }
6218 return resultobj;
6219 fail:
6220 {
6221 if (temp1)
6222 delete arg1;
6223 }
6224 return NULL;
6225 }
6226
6227
6228 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6229 PyObject *resultobj;
6230 wxToolTip *arg1 = (wxToolTip *) 0 ;
6231 wxString *arg2 = 0 ;
6232 bool temp2 = false ;
6233 PyObject * obj0 = 0 ;
6234 PyObject * obj1 = 0 ;
6235 char *kwnames[] = {
6236 (char *) "self",(char *) "tip", NULL
6237 };
6238
6239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6241 if (SWIG_arg_fail(1)) SWIG_fail;
6242 {
6243 arg2 = wxString_in_helper(obj1);
6244 if (arg2 == NULL) SWIG_fail;
6245 temp2 = true;
6246 }
6247 {
6248 PyThreadState* __tstate = wxPyBeginAllowThreads();
6249 (arg1)->SetTip((wxString const &)*arg2);
6250
6251 wxPyEndAllowThreads(__tstate);
6252 if (PyErr_Occurred()) SWIG_fail;
6253 }
6254 Py_INCREF(Py_None); resultobj = Py_None;
6255 {
6256 if (temp2)
6257 delete arg2;
6258 }
6259 return resultobj;
6260 fail:
6261 {
6262 if (temp2)
6263 delete arg2;
6264 }
6265 return NULL;
6266 }
6267
6268
6269 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6270 PyObject *resultobj;
6271 wxToolTip *arg1 = (wxToolTip *) 0 ;
6272 wxString result;
6273 PyObject * obj0 = 0 ;
6274 char *kwnames[] = {
6275 (char *) "self", NULL
6276 };
6277
6278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6280 if (SWIG_arg_fail(1)) SWIG_fail;
6281 {
6282 PyThreadState* __tstate = wxPyBeginAllowThreads();
6283 result = (arg1)->GetTip();
6284
6285 wxPyEndAllowThreads(__tstate);
6286 if (PyErr_Occurred()) SWIG_fail;
6287 }
6288 {
6289 #if wxUSE_UNICODE
6290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6291 #else
6292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6293 #endif
6294 }
6295 return resultobj;
6296 fail:
6297 return NULL;
6298 }
6299
6300
6301 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6302 PyObject *resultobj;
6303 wxToolTip *arg1 = (wxToolTip *) 0 ;
6304 wxWindow *result;
6305 PyObject * obj0 = 0 ;
6306 char *kwnames[] = {
6307 (char *) "self", NULL
6308 };
6309
6310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6312 if (SWIG_arg_fail(1)) SWIG_fail;
6313 {
6314 PyThreadState* __tstate = wxPyBeginAllowThreads();
6315 result = (wxWindow *)(arg1)->GetWindow();
6316
6317 wxPyEndAllowThreads(__tstate);
6318 if (PyErr_Occurred()) SWIG_fail;
6319 }
6320 {
6321 resultobj = wxPyMake_wxObject(result, 0);
6322 }
6323 return resultobj;
6324 fail:
6325 return NULL;
6326 }
6327
6328
6329 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6330 PyObject *resultobj;
6331 bool arg1 ;
6332 PyObject * obj0 = 0 ;
6333 char *kwnames[] = {
6334 (char *) "flag", NULL
6335 };
6336
6337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6338 {
6339 arg1 = (bool)(SWIG_As_bool(obj0));
6340 if (SWIG_arg_fail(1)) SWIG_fail;
6341 }
6342 {
6343 PyThreadState* __tstate = wxPyBeginAllowThreads();
6344 wxToolTip::Enable(arg1);
6345
6346 wxPyEndAllowThreads(__tstate);
6347 if (PyErr_Occurred()) SWIG_fail;
6348 }
6349 Py_INCREF(Py_None); resultobj = Py_None;
6350 return resultobj;
6351 fail:
6352 return NULL;
6353 }
6354
6355
6356 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6357 PyObject *resultobj;
6358 long arg1 ;
6359 PyObject * obj0 = 0 ;
6360 char *kwnames[] = {
6361 (char *) "milliseconds", NULL
6362 };
6363
6364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6365 {
6366 arg1 = (long)(SWIG_As_long(obj0));
6367 if (SWIG_arg_fail(1)) SWIG_fail;
6368 }
6369 {
6370 PyThreadState* __tstate = wxPyBeginAllowThreads();
6371 wxToolTip::SetDelay(arg1);
6372
6373 wxPyEndAllowThreads(__tstate);
6374 if (PyErr_Occurred()) SWIG_fail;
6375 }
6376 Py_INCREF(Py_None); resultobj = Py_None;
6377 return resultobj;
6378 fail:
6379 return NULL;
6380 }
6381
6382
6383 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6384 PyObject *obj;
6385 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6386 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6387 Py_INCREF(obj);
6388 return Py_BuildValue((char *)"");
6389 }
6390 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6391 PyObject *resultobj;
6392 wxWindow *arg1 = (wxWindow *) 0 ;
6393 wxSize *arg2 = 0 ;
6394 wxCaret *result;
6395 wxSize temp2 ;
6396 PyObject * obj0 = 0 ;
6397 PyObject * obj1 = 0 ;
6398 char *kwnames[] = {
6399 (char *) "window",(char *) "size", NULL
6400 };
6401
6402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6404 if (SWIG_arg_fail(1)) SWIG_fail;
6405 {
6406 arg2 = &temp2;
6407 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6408 }
6409 {
6410 if (!wxPyCheckForApp()) SWIG_fail;
6411 PyThreadState* __tstate = wxPyBeginAllowThreads();
6412 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6413
6414 wxPyEndAllowThreads(__tstate);
6415 if (PyErr_Occurred()) SWIG_fail;
6416 }
6417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6418 return resultobj;
6419 fail:
6420 return NULL;
6421 }
6422
6423
6424 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6425 PyObject *resultobj;
6426 wxCaret *arg1 = (wxCaret *) 0 ;
6427 PyObject * obj0 = 0 ;
6428 char *kwnames[] = {
6429 (char *) "self", NULL
6430 };
6431
6432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6434 if (SWIG_arg_fail(1)) SWIG_fail;
6435 {
6436 PyThreadState* __tstate = wxPyBeginAllowThreads();
6437 wxCaret_Destroy(arg1);
6438
6439 wxPyEndAllowThreads(__tstate);
6440 if (PyErr_Occurred()) SWIG_fail;
6441 }
6442 Py_INCREF(Py_None); resultobj = Py_None;
6443 return resultobj;
6444 fail:
6445 return NULL;
6446 }
6447
6448
6449 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6450 PyObject *resultobj;
6451 wxCaret *arg1 = (wxCaret *) 0 ;
6452 bool result;
6453 PyObject * obj0 = 0 ;
6454 char *kwnames[] = {
6455 (char *) "self", NULL
6456 };
6457
6458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6460 if (SWIG_arg_fail(1)) SWIG_fail;
6461 {
6462 PyThreadState* __tstate = wxPyBeginAllowThreads();
6463 result = (bool)(arg1)->IsOk();
6464
6465 wxPyEndAllowThreads(__tstate);
6466 if (PyErr_Occurred()) SWIG_fail;
6467 }
6468 {
6469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6470 }
6471 return resultobj;
6472 fail:
6473 return NULL;
6474 }
6475
6476
6477 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6478 PyObject *resultobj;
6479 wxCaret *arg1 = (wxCaret *) 0 ;
6480 bool result;
6481 PyObject * obj0 = 0 ;
6482 char *kwnames[] = {
6483 (char *) "self", NULL
6484 };
6485
6486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6488 if (SWIG_arg_fail(1)) SWIG_fail;
6489 {
6490 PyThreadState* __tstate = wxPyBeginAllowThreads();
6491 result = (bool)(arg1)->IsVisible();
6492
6493 wxPyEndAllowThreads(__tstate);
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 {
6497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6498 }
6499 return resultobj;
6500 fail:
6501 return NULL;
6502 }
6503
6504
6505 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6506 PyObject *resultobj;
6507 wxCaret *arg1 = (wxCaret *) 0 ;
6508 wxPoint result;
6509 PyObject * obj0 = 0 ;
6510 char *kwnames[] = {
6511 (char *) "self", NULL
6512 };
6513
6514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6516 if (SWIG_arg_fail(1)) SWIG_fail;
6517 {
6518 PyThreadState* __tstate = wxPyBeginAllowThreads();
6519 result = (arg1)->GetPosition();
6520
6521 wxPyEndAllowThreads(__tstate);
6522 if (PyErr_Occurred()) SWIG_fail;
6523 }
6524 {
6525 wxPoint * resultptr;
6526 resultptr = new wxPoint((wxPoint &)(result));
6527 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6528 }
6529 return resultobj;
6530 fail:
6531 return NULL;
6532 }
6533
6534
6535 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6536 PyObject *resultobj;
6537 wxCaret *arg1 = (wxCaret *) 0 ;
6538 int *arg2 = (int *) 0 ;
6539 int *arg3 = (int *) 0 ;
6540 int temp2 ;
6541 int res2 = 0 ;
6542 int temp3 ;
6543 int res3 = 0 ;
6544 PyObject * obj0 = 0 ;
6545 char *kwnames[] = {
6546 (char *) "self", NULL
6547 };
6548
6549 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6550 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6553 if (SWIG_arg_fail(1)) SWIG_fail;
6554 {
6555 PyThreadState* __tstate = wxPyBeginAllowThreads();
6556 (arg1)->GetPosition(arg2,arg3);
6557
6558 wxPyEndAllowThreads(__tstate);
6559 if (PyErr_Occurred()) SWIG_fail;
6560 }
6561 Py_INCREF(Py_None); resultobj = Py_None;
6562 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6563 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6564 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6565 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6566 return resultobj;
6567 fail:
6568 return NULL;
6569 }
6570
6571
6572 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6573 PyObject *resultobj;
6574 wxCaret *arg1 = (wxCaret *) 0 ;
6575 wxSize result;
6576 PyObject * obj0 = 0 ;
6577 char *kwnames[] = {
6578 (char *) "self", NULL
6579 };
6580
6581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6583 if (SWIG_arg_fail(1)) SWIG_fail;
6584 {
6585 PyThreadState* __tstate = wxPyBeginAllowThreads();
6586 result = (arg1)->GetSize();
6587
6588 wxPyEndAllowThreads(__tstate);
6589 if (PyErr_Occurred()) SWIG_fail;
6590 }
6591 {
6592 wxSize * resultptr;
6593 resultptr = new wxSize((wxSize &)(result));
6594 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6595 }
6596 return resultobj;
6597 fail:
6598 return NULL;
6599 }
6600
6601
6602 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6603 PyObject *resultobj;
6604 wxCaret *arg1 = (wxCaret *) 0 ;
6605 int *arg2 = (int *) 0 ;
6606 int *arg3 = (int *) 0 ;
6607 int temp2 ;
6608 int res2 = 0 ;
6609 int temp3 ;
6610 int res3 = 0 ;
6611 PyObject * obj0 = 0 ;
6612 char *kwnames[] = {
6613 (char *) "self", NULL
6614 };
6615
6616 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6617 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6620 if (SWIG_arg_fail(1)) SWIG_fail;
6621 {
6622 PyThreadState* __tstate = wxPyBeginAllowThreads();
6623 (arg1)->GetSize(arg2,arg3);
6624
6625 wxPyEndAllowThreads(__tstate);
6626 if (PyErr_Occurred()) SWIG_fail;
6627 }
6628 Py_INCREF(Py_None); resultobj = Py_None;
6629 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6630 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6631 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6632 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6633 return resultobj;
6634 fail:
6635 return NULL;
6636 }
6637
6638
6639 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6640 PyObject *resultobj;
6641 wxCaret *arg1 = (wxCaret *) 0 ;
6642 wxWindow *result;
6643 PyObject * obj0 = 0 ;
6644 char *kwnames[] = {
6645 (char *) "self", NULL
6646 };
6647
6648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6650 if (SWIG_arg_fail(1)) SWIG_fail;
6651 {
6652 PyThreadState* __tstate = wxPyBeginAllowThreads();
6653 result = (wxWindow *)(arg1)->GetWindow();
6654
6655 wxPyEndAllowThreads(__tstate);
6656 if (PyErr_Occurred()) SWIG_fail;
6657 }
6658 {
6659 resultobj = wxPyMake_wxObject(result, 0);
6660 }
6661 return resultobj;
6662 fail:
6663 return NULL;
6664 }
6665
6666
6667 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6668 PyObject *resultobj;
6669 wxCaret *arg1 = (wxCaret *) 0 ;
6670 int arg2 ;
6671 int arg3 ;
6672 PyObject * obj0 = 0 ;
6673 PyObject * obj1 = 0 ;
6674 PyObject * obj2 = 0 ;
6675 char *kwnames[] = {
6676 (char *) "self",(char *) "x",(char *) "y", NULL
6677 };
6678
6679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6681 if (SWIG_arg_fail(1)) SWIG_fail;
6682 {
6683 arg2 = (int)(SWIG_As_int(obj1));
6684 if (SWIG_arg_fail(2)) SWIG_fail;
6685 }
6686 {
6687 arg3 = (int)(SWIG_As_int(obj2));
6688 if (SWIG_arg_fail(3)) SWIG_fail;
6689 }
6690 {
6691 PyThreadState* __tstate = wxPyBeginAllowThreads();
6692 (arg1)->Move(arg2,arg3);
6693
6694 wxPyEndAllowThreads(__tstate);
6695 if (PyErr_Occurred()) SWIG_fail;
6696 }
6697 Py_INCREF(Py_None); resultobj = Py_None;
6698 return resultobj;
6699 fail:
6700 return NULL;
6701 }
6702
6703
6704 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6705 PyObject *resultobj;
6706 wxCaret *arg1 = (wxCaret *) 0 ;
6707 wxPoint *arg2 = 0 ;
6708 wxPoint temp2 ;
6709 PyObject * obj0 = 0 ;
6710 PyObject * obj1 = 0 ;
6711 char *kwnames[] = {
6712 (char *) "self",(char *) "pt", NULL
6713 };
6714
6715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6717 if (SWIG_arg_fail(1)) SWIG_fail;
6718 {
6719 arg2 = &temp2;
6720 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6721 }
6722 {
6723 PyThreadState* __tstate = wxPyBeginAllowThreads();
6724 (arg1)->Move((wxPoint const &)*arg2);
6725
6726 wxPyEndAllowThreads(__tstate);
6727 if (PyErr_Occurred()) SWIG_fail;
6728 }
6729 Py_INCREF(Py_None); resultobj = Py_None;
6730 return resultobj;
6731 fail:
6732 return NULL;
6733 }
6734
6735
6736 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6737 PyObject *resultobj;
6738 wxCaret *arg1 = (wxCaret *) 0 ;
6739 int arg2 ;
6740 int arg3 ;
6741 PyObject * obj0 = 0 ;
6742 PyObject * obj1 = 0 ;
6743 PyObject * obj2 = 0 ;
6744 char *kwnames[] = {
6745 (char *) "self",(char *) "width",(char *) "height", NULL
6746 };
6747
6748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6750 if (SWIG_arg_fail(1)) SWIG_fail;
6751 {
6752 arg2 = (int)(SWIG_As_int(obj1));
6753 if (SWIG_arg_fail(2)) SWIG_fail;
6754 }
6755 {
6756 arg3 = (int)(SWIG_As_int(obj2));
6757 if (SWIG_arg_fail(3)) SWIG_fail;
6758 }
6759 {
6760 PyThreadState* __tstate = wxPyBeginAllowThreads();
6761 (arg1)->SetSize(arg2,arg3);
6762
6763 wxPyEndAllowThreads(__tstate);
6764 if (PyErr_Occurred()) SWIG_fail;
6765 }
6766 Py_INCREF(Py_None); resultobj = Py_None;
6767 return resultobj;
6768 fail:
6769 return NULL;
6770 }
6771
6772
6773 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6774 PyObject *resultobj;
6775 wxCaret *arg1 = (wxCaret *) 0 ;
6776 wxSize *arg2 = 0 ;
6777 wxSize temp2 ;
6778 PyObject * obj0 = 0 ;
6779 PyObject * obj1 = 0 ;
6780 char *kwnames[] = {
6781 (char *) "self",(char *) "size", NULL
6782 };
6783
6784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6786 if (SWIG_arg_fail(1)) SWIG_fail;
6787 {
6788 arg2 = &temp2;
6789 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6790 }
6791 {
6792 PyThreadState* __tstate = wxPyBeginAllowThreads();
6793 (arg1)->SetSize((wxSize const &)*arg2);
6794
6795 wxPyEndAllowThreads(__tstate);
6796 if (PyErr_Occurred()) SWIG_fail;
6797 }
6798 Py_INCREF(Py_None); resultobj = Py_None;
6799 return resultobj;
6800 fail:
6801 return NULL;
6802 }
6803
6804
6805 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6806 PyObject *resultobj;
6807 wxCaret *arg1 = (wxCaret *) 0 ;
6808 int arg2 = (int) true ;
6809 PyObject * obj0 = 0 ;
6810 PyObject * obj1 = 0 ;
6811 char *kwnames[] = {
6812 (char *) "self",(char *) "show", NULL
6813 };
6814
6815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6817 if (SWIG_arg_fail(1)) SWIG_fail;
6818 if (obj1) {
6819 {
6820 arg2 = (int)(SWIG_As_int(obj1));
6821 if (SWIG_arg_fail(2)) SWIG_fail;
6822 }
6823 }
6824 {
6825 PyThreadState* __tstate = wxPyBeginAllowThreads();
6826 (arg1)->Show(arg2);
6827
6828 wxPyEndAllowThreads(__tstate);
6829 if (PyErr_Occurred()) SWIG_fail;
6830 }
6831 Py_INCREF(Py_None); resultobj = Py_None;
6832 return resultobj;
6833 fail:
6834 return NULL;
6835 }
6836
6837
6838 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6839 PyObject *resultobj;
6840 wxCaret *arg1 = (wxCaret *) 0 ;
6841 PyObject * obj0 = 0 ;
6842 char *kwnames[] = {
6843 (char *) "self", NULL
6844 };
6845
6846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6848 if (SWIG_arg_fail(1)) SWIG_fail;
6849 {
6850 PyThreadState* __tstate = wxPyBeginAllowThreads();
6851 (arg1)->Hide();
6852
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 Py_INCREF(Py_None); resultobj = Py_None;
6857 return resultobj;
6858 fail:
6859 return NULL;
6860 }
6861
6862
6863 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6864 PyObject *resultobj;
6865 int result;
6866 char *kwnames[] = {
6867 NULL
6868 };
6869
6870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6871 {
6872 PyThreadState* __tstate = wxPyBeginAllowThreads();
6873 result = (int)wxCaret::GetBlinkTime();
6874
6875 wxPyEndAllowThreads(__tstate);
6876 if (PyErr_Occurred()) SWIG_fail;
6877 }
6878 {
6879 resultobj = SWIG_From_int((int)(result));
6880 }
6881 return resultobj;
6882 fail:
6883 return NULL;
6884 }
6885
6886
6887 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6888 PyObject *resultobj;
6889 int arg1 ;
6890 PyObject * obj0 = 0 ;
6891 char *kwnames[] = {
6892 (char *) "milliseconds", NULL
6893 };
6894
6895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6896 {
6897 arg1 = (int)(SWIG_As_int(obj0));
6898 if (SWIG_arg_fail(1)) SWIG_fail;
6899 }
6900 {
6901 PyThreadState* __tstate = wxPyBeginAllowThreads();
6902 wxCaret::SetBlinkTime(arg1);
6903
6904 wxPyEndAllowThreads(__tstate);
6905 if (PyErr_Occurred()) SWIG_fail;
6906 }
6907 Py_INCREF(Py_None); resultobj = Py_None;
6908 return resultobj;
6909 fail:
6910 return NULL;
6911 }
6912
6913
6914 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6915 PyObject *obj;
6916 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6917 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6918 Py_INCREF(obj);
6919 return Py_BuildValue((char *)"");
6920 }
6921 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6922 PyObject *resultobj;
6923 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6924 wxBusyCursor *result;
6925 PyObject * obj0 = 0 ;
6926 char *kwnames[] = {
6927 (char *) "cursor", NULL
6928 };
6929
6930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6931 if (obj0) {
6932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6933 if (SWIG_arg_fail(1)) SWIG_fail;
6934 }
6935 {
6936 if (!wxPyCheckForApp()) SWIG_fail;
6937 PyThreadState* __tstate = wxPyBeginAllowThreads();
6938 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6939
6940 wxPyEndAllowThreads(__tstate);
6941 if (PyErr_Occurred()) SWIG_fail;
6942 }
6943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6944 return resultobj;
6945 fail:
6946 return NULL;
6947 }
6948
6949
6950 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6951 PyObject *resultobj;
6952 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6953 PyObject * obj0 = 0 ;
6954 char *kwnames[] = {
6955 (char *) "self", NULL
6956 };
6957
6958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6960 if (SWIG_arg_fail(1)) SWIG_fail;
6961 {
6962 PyThreadState* __tstate = wxPyBeginAllowThreads();
6963 delete arg1;
6964
6965 wxPyEndAllowThreads(__tstate);
6966 if (PyErr_Occurred()) SWIG_fail;
6967 }
6968 Py_INCREF(Py_None); resultobj = Py_None;
6969 return resultobj;
6970 fail:
6971 return NULL;
6972 }
6973
6974
6975 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6976 PyObject *obj;
6977 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6978 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6979 Py_INCREF(obj);
6980 return Py_BuildValue((char *)"");
6981 }
6982 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6983 PyObject *resultobj;
6984 wxWindow *arg1 = (wxWindow *) NULL ;
6985 wxWindowDisabler *result;
6986 PyObject * obj0 = 0 ;
6987 char *kwnames[] = {
6988 (char *) "winToSkip", NULL
6989 };
6990
6991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6992 if (obj0) {
6993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6994 if (SWIG_arg_fail(1)) SWIG_fail;
6995 }
6996 {
6997 if (!wxPyCheckForApp()) SWIG_fail;
6998 PyThreadState* __tstate = wxPyBeginAllowThreads();
6999 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7000
7001 wxPyEndAllowThreads(__tstate);
7002 if (PyErr_Occurred()) SWIG_fail;
7003 }
7004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7005 return resultobj;
7006 fail:
7007 return NULL;
7008 }
7009
7010
7011 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7012 PyObject *resultobj;
7013 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7014 PyObject * obj0 = 0 ;
7015 char *kwnames[] = {
7016 (char *) "self", NULL
7017 };
7018
7019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7021 if (SWIG_arg_fail(1)) SWIG_fail;
7022 {
7023 PyThreadState* __tstate = wxPyBeginAllowThreads();
7024 delete arg1;
7025
7026 wxPyEndAllowThreads(__tstate);
7027 if (PyErr_Occurred()) SWIG_fail;
7028 }
7029 Py_INCREF(Py_None); resultobj = Py_None;
7030 return resultobj;
7031 fail:
7032 return NULL;
7033 }
7034
7035
7036 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7037 PyObject *obj;
7038 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7039 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7040 Py_INCREF(obj);
7041 return Py_BuildValue((char *)"");
7042 }
7043 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7044 PyObject *resultobj;
7045 wxString *arg1 = 0 ;
7046 wxBusyInfo *result;
7047 bool temp1 = false ;
7048 PyObject * obj0 = 0 ;
7049 char *kwnames[] = {
7050 (char *) "message", NULL
7051 };
7052
7053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7054 {
7055 arg1 = wxString_in_helper(obj0);
7056 if (arg1 == NULL) SWIG_fail;
7057 temp1 = true;
7058 }
7059 {
7060 if (!wxPyCheckForApp()) SWIG_fail;
7061 PyThreadState* __tstate = wxPyBeginAllowThreads();
7062 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7063
7064 wxPyEndAllowThreads(__tstate);
7065 if (PyErr_Occurred()) SWIG_fail;
7066 }
7067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7068 {
7069 if (temp1)
7070 delete arg1;
7071 }
7072 return resultobj;
7073 fail:
7074 {
7075 if (temp1)
7076 delete arg1;
7077 }
7078 return NULL;
7079 }
7080
7081
7082 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7083 PyObject *resultobj;
7084 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7085 PyObject * obj0 = 0 ;
7086 char *kwnames[] = {
7087 (char *) "self", NULL
7088 };
7089
7090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7092 if (SWIG_arg_fail(1)) SWIG_fail;
7093 {
7094 PyThreadState* __tstate = wxPyBeginAllowThreads();
7095 delete arg1;
7096
7097 wxPyEndAllowThreads(__tstate);
7098 if (PyErr_Occurred()) SWIG_fail;
7099 }
7100 Py_INCREF(Py_None); resultobj = Py_None;
7101 return resultobj;
7102 fail:
7103 return NULL;
7104 }
7105
7106
7107 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7108 PyObject *obj;
7109 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7110 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7111 Py_INCREF(obj);
7112 return Py_BuildValue((char *)"");
7113 }
7114 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7115 PyObject *resultobj;
7116 wxStopWatch *result;
7117 char *kwnames[] = {
7118 NULL
7119 };
7120
7121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7122 {
7123 PyThreadState* __tstate = wxPyBeginAllowThreads();
7124 result = (wxStopWatch *)new wxStopWatch();
7125
7126 wxPyEndAllowThreads(__tstate);
7127 if (PyErr_Occurred()) SWIG_fail;
7128 }
7129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7137 PyObject *resultobj;
7138 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7139 long arg2 = (long) 0 ;
7140 PyObject * obj0 = 0 ;
7141 PyObject * obj1 = 0 ;
7142 char *kwnames[] = {
7143 (char *) "self",(char *) "t0", NULL
7144 };
7145
7146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7148 if (SWIG_arg_fail(1)) SWIG_fail;
7149 if (obj1) {
7150 {
7151 arg2 = (long)(SWIG_As_long(obj1));
7152 if (SWIG_arg_fail(2)) SWIG_fail;
7153 }
7154 }
7155 {
7156 PyThreadState* __tstate = wxPyBeginAllowThreads();
7157 (arg1)->Start(arg2);
7158
7159 wxPyEndAllowThreads(__tstate);
7160 if (PyErr_Occurred()) SWIG_fail;
7161 }
7162 Py_INCREF(Py_None); resultobj = Py_None;
7163 return resultobj;
7164 fail:
7165 return NULL;
7166 }
7167
7168
7169 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7170 PyObject *resultobj;
7171 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7172 PyObject * obj0 = 0 ;
7173 char *kwnames[] = {
7174 (char *) "self", NULL
7175 };
7176
7177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7179 if (SWIG_arg_fail(1)) SWIG_fail;
7180 {
7181 PyThreadState* __tstate = wxPyBeginAllowThreads();
7182 (arg1)->Pause();
7183
7184 wxPyEndAllowThreads(__tstate);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 Py_INCREF(Py_None); resultobj = Py_None;
7188 return resultobj;
7189 fail:
7190 return NULL;
7191 }
7192
7193
7194 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7195 PyObject *resultobj;
7196 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7197 PyObject * obj0 = 0 ;
7198 char *kwnames[] = {
7199 (char *) "self", NULL
7200 };
7201
7202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7204 if (SWIG_arg_fail(1)) SWIG_fail;
7205 {
7206 PyThreadState* __tstate = wxPyBeginAllowThreads();
7207 (arg1)->Resume();
7208
7209 wxPyEndAllowThreads(__tstate);
7210 if (PyErr_Occurred()) SWIG_fail;
7211 }
7212 Py_INCREF(Py_None); resultobj = Py_None;
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj;
7221 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7222 long result;
7223 PyObject * obj0 = 0 ;
7224 char *kwnames[] = {
7225 (char *) "self", NULL
7226 };
7227
7228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7230 if (SWIG_arg_fail(1)) SWIG_fail;
7231 {
7232 PyThreadState* __tstate = wxPyBeginAllowThreads();
7233 result = (long)((wxStopWatch const *)arg1)->Time();
7234
7235 wxPyEndAllowThreads(__tstate);
7236 if (PyErr_Occurred()) SWIG_fail;
7237 }
7238 {
7239 resultobj = SWIG_From_long((long)(result));
7240 }
7241 return resultobj;
7242 fail:
7243 return NULL;
7244 }
7245
7246
7247 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7248 PyObject *obj;
7249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7250 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7251 Py_INCREF(obj);
7252 return Py_BuildValue((char *)"");
7253 }
7254 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7255 PyObject *resultobj;
7256 int arg1 = (int) 9 ;
7257 int arg2 = (int) wxID_FILE1 ;
7258 wxFileHistory *result;
7259 PyObject * obj0 = 0 ;
7260 PyObject * obj1 = 0 ;
7261 char *kwnames[] = {
7262 (char *) "maxFiles",(char *) "idBase", NULL
7263 };
7264
7265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7266 if (obj0) {
7267 {
7268 arg1 = (int)(SWIG_As_int(obj0));
7269 if (SWIG_arg_fail(1)) SWIG_fail;
7270 }
7271 }
7272 if (obj1) {
7273 {
7274 arg2 = (int)(SWIG_As_int(obj1));
7275 if (SWIG_arg_fail(2)) SWIG_fail;
7276 }
7277 }
7278 {
7279 PyThreadState* __tstate = wxPyBeginAllowThreads();
7280 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7281
7282 wxPyEndAllowThreads(__tstate);
7283 if (PyErr_Occurred()) SWIG_fail;
7284 }
7285 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7286 return resultobj;
7287 fail:
7288 return NULL;
7289 }
7290
7291
7292 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7293 PyObject *resultobj;
7294 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7295 PyObject * obj0 = 0 ;
7296 char *kwnames[] = {
7297 (char *) "self", NULL
7298 };
7299
7300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7302 if (SWIG_arg_fail(1)) SWIG_fail;
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 delete arg1;
7306
7307 wxPyEndAllowThreads(__tstate);
7308 if (PyErr_Occurred()) SWIG_fail;
7309 }
7310 Py_INCREF(Py_None); resultobj = Py_None;
7311 return resultobj;
7312 fail:
7313 return NULL;
7314 }
7315
7316
7317 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7318 PyObject *resultobj;
7319 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7320 wxString *arg2 = 0 ;
7321 bool temp2 = false ;
7322 PyObject * obj0 = 0 ;
7323 PyObject * obj1 = 0 ;
7324 char *kwnames[] = {
7325 (char *) "self",(char *) "file", NULL
7326 };
7327
7328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7330 if (SWIG_arg_fail(1)) SWIG_fail;
7331 {
7332 arg2 = wxString_in_helper(obj1);
7333 if (arg2 == NULL) SWIG_fail;
7334 temp2 = true;
7335 }
7336 {
7337 PyThreadState* __tstate = wxPyBeginAllowThreads();
7338 (arg1)->AddFileToHistory((wxString const &)*arg2);
7339
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 Py_INCREF(Py_None); resultobj = Py_None;
7344 {
7345 if (temp2)
7346 delete arg2;
7347 }
7348 return resultobj;
7349 fail:
7350 {
7351 if (temp2)
7352 delete arg2;
7353 }
7354 return NULL;
7355 }
7356
7357
7358 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7359 PyObject *resultobj;
7360 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7361 int arg2 ;
7362 PyObject * obj0 = 0 ;
7363 PyObject * obj1 = 0 ;
7364 char *kwnames[] = {
7365 (char *) "self",(char *) "i", NULL
7366 };
7367
7368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7370 if (SWIG_arg_fail(1)) SWIG_fail;
7371 {
7372 arg2 = (int)(SWIG_As_int(obj1));
7373 if (SWIG_arg_fail(2)) SWIG_fail;
7374 }
7375 {
7376 PyThreadState* __tstate = wxPyBeginAllowThreads();
7377 (arg1)->RemoveFileFromHistory(arg2);
7378
7379 wxPyEndAllowThreads(__tstate);
7380 if (PyErr_Occurred()) SWIG_fail;
7381 }
7382 Py_INCREF(Py_None); resultobj = Py_None;
7383 return resultobj;
7384 fail:
7385 return NULL;
7386 }
7387
7388
7389 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7390 PyObject *resultobj;
7391 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7392 int result;
7393 PyObject * obj0 = 0 ;
7394 char *kwnames[] = {
7395 (char *) "self", NULL
7396 };
7397
7398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7400 if (SWIG_arg_fail(1)) SWIG_fail;
7401 {
7402 PyThreadState* __tstate = wxPyBeginAllowThreads();
7403 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7404
7405 wxPyEndAllowThreads(__tstate);
7406 if (PyErr_Occurred()) SWIG_fail;
7407 }
7408 {
7409 resultobj = SWIG_From_int((int)(result));
7410 }
7411 return resultobj;
7412 fail:
7413 return NULL;
7414 }
7415
7416
7417 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7418 PyObject *resultobj;
7419 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7420 wxMenu *arg2 = (wxMenu *) 0 ;
7421 PyObject * obj0 = 0 ;
7422 PyObject * obj1 = 0 ;
7423 char *kwnames[] = {
7424 (char *) "self",(char *) "menu", NULL
7425 };
7426
7427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7429 if (SWIG_arg_fail(1)) SWIG_fail;
7430 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7431 if (SWIG_arg_fail(2)) SWIG_fail;
7432 {
7433 PyThreadState* __tstate = wxPyBeginAllowThreads();
7434 (arg1)->UseMenu(arg2);
7435
7436 wxPyEndAllowThreads(__tstate);
7437 if (PyErr_Occurred()) SWIG_fail;
7438 }
7439 Py_INCREF(Py_None); resultobj = Py_None;
7440 return resultobj;
7441 fail:
7442 return NULL;
7443 }
7444
7445
7446 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7447 PyObject *resultobj;
7448 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7449 wxMenu *arg2 = (wxMenu *) 0 ;
7450 PyObject * obj0 = 0 ;
7451 PyObject * obj1 = 0 ;
7452 char *kwnames[] = {
7453 (char *) "self",(char *) "menu", NULL
7454 };
7455
7456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7458 if (SWIG_arg_fail(1)) SWIG_fail;
7459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7460 if (SWIG_arg_fail(2)) SWIG_fail;
7461 {
7462 PyThreadState* __tstate = wxPyBeginAllowThreads();
7463 (arg1)->RemoveMenu(arg2);
7464
7465 wxPyEndAllowThreads(__tstate);
7466 if (PyErr_Occurred()) SWIG_fail;
7467 }
7468 Py_INCREF(Py_None); resultobj = Py_None;
7469 return resultobj;
7470 fail:
7471 return NULL;
7472 }
7473
7474
7475 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7476 PyObject *resultobj;
7477 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7478 wxConfigBase *arg2 = 0 ;
7479 PyObject * obj0 = 0 ;
7480 PyObject * obj1 = 0 ;
7481 char *kwnames[] = {
7482 (char *) "self",(char *) "config", NULL
7483 };
7484
7485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7487 if (SWIG_arg_fail(1)) SWIG_fail;
7488 {
7489 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7490 if (SWIG_arg_fail(2)) SWIG_fail;
7491 if (arg2 == NULL) {
7492 SWIG_null_ref("wxConfigBase");
7493 }
7494 if (SWIG_arg_fail(2)) SWIG_fail;
7495 }
7496 {
7497 PyThreadState* __tstate = wxPyBeginAllowThreads();
7498 (arg1)->Load(*arg2);
7499
7500 wxPyEndAllowThreads(__tstate);
7501 if (PyErr_Occurred()) SWIG_fail;
7502 }
7503 Py_INCREF(Py_None); resultobj = Py_None;
7504 return resultobj;
7505 fail:
7506 return NULL;
7507 }
7508
7509
7510 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7511 PyObject *resultobj;
7512 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7513 wxConfigBase *arg2 = 0 ;
7514 PyObject * obj0 = 0 ;
7515 PyObject * obj1 = 0 ;
7516 char *kwnames[] = {
7517 (char *) "self",(char *) "config", NULL
7518 };
7519
7520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7522 if (SWIG_arg_fail(1)) SWIG_fail;
7523 {
7524 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7525 if (SWIG_arg_fail(2)) SWIG_fail;
7526 if (arg2 == NULL) {
7527 SWIG_null_ref("wxConfigBase");
7528 }
7529 if (SWIG_arg_fail(2)) SWIG_fail;
7530 }
7531 {
7532 PyThreadState* __tstate = wxPyBeginAllowThreads();
7533 (arg1)->Save(*arg2);
7534
7535 wxPyEndAllowThreads(__tstate);
7536 if (PyErr_Occurred()) SWIG_fail;
7537 }
7538 Py_INCREF(Py_None); resultobj = Py_None;
7539 return resultobj;
7540 fail:
7541 return NULL;
7542 }
7543
7544
7545 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7546 PyObject *resultobj;
7547 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7548 PyObject * obj0 = 0 ;
7549 char *kwnames[] = {
7550 (char *) "self", NULL
7551 };
7552
7553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7555 if (SWIG_arg_fail(1)) SWIG_fail;
7556 {
7557 PyThreadState* __tstate = wxPyBeginAllowThreads();
7558 (arg1)->AddFilesToMenu();
7559
7560 wxPyEndAllowThreads(__tstate);
7561 if (PyErr_Occurred()) SWIG_fail;
7562 }
7563 Py_INCREF(Py_None); resultobj = Py_None;
7564 return resultobj;
7565 fail:
7566 return NULL;
7567 }
7568
7569
7570 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7571 PyObject *resultobj;
7572 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7573 wxMenu *arg2 = (wxMenu *) 0 ;
7574 PyObject * obj0 = 0 ;
7575 PyObject * obj1 = 0 ;
7576 char *kwnames[] = {
7577 (char *) "self",(char *) "menu", NULL
7578 };
7579
7580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7582 if (SWIG_arg_fail(1)) SWIG_fail;
7583 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7584 if (SWIG_arg_fail(2)) SWIG_fail;
7585 {
7586 PyThreadState* __tstate = wxPyBeginAllowThreads();
7587 (arg1)->AddFilesToMenu(arg2);
7588
7589 wxPyEndAllowThreads(__tstate);
7590 if (PyErr_Occurred()) SWIG_fail;
7591 }
7592 Py_INCREF(Py_None); resultobj = Py_None;
7593 return resultobj;
7594 fail:
7595 return NULL;
7596 }
7597
7598
7599 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7600 PyObject *resultobj;
7601 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7602 int arg2 ;
7603 wxString result;
7604 PyObject * obj0 = 0 ;
7605 PyObject * obj1 = 0 ;
7606 char *kwnames[] = {
7607 (char *) "self",(char *) "i", NULL
7608 };
7609
7610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7612 if (SWIG_arg_fail(1)) SWIG_fail;
7613 {
7614 arg2 = (int)(SWIG_As_int(obj1));
7615 if (SWIG_arg_fail(2)) SWIG_fail;
7616 }
7617 {
7618 PyThreadState* __tstate = wxPyBeginAllowThreads();
7619 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7620
7621 wxPyEndAllowThreads(__tstate);
7622 if (PyErr_Occurred()) SWIG_fail;
7623 }
7624 {
7625 #if wxUSE_UNICODE
7626 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7627 #else
7628 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7629 #endif
7630 }
7631 return resultobj;
7632 fail:
7633 return NULL;
7634 }
7635
7636
7637 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7638 PyObject *resultobj;
7639 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7640 int result;
7641 PyObject * obj0 = 0 ;
7642 char *kwnames[] = {
7643 (char *) "self", NULL
7644 };
7645
7646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7648 if (SWIG_arg_fail(1)) SWIG_fail;
7649 {
7650 PyThreadState* __tstate = wxPyBeginAllowThreads();
7651 result = (int)((wxFileHistory const *)arg1)->GetCount();
7652
7653 wxPyEndAllowThreads(__tstate);
7654 if (PyErr_Occurred()) SWIG_fail;
7655 }
7656 {
7657 resultobj = SWIG_From_int((int)(result));
7658 }
7659 return resultobj;
7660 fail:
7661 return NULL;
7662 }
7663
7664
7665 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7666 PyObject *obj;
7667 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7668 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7669 Py_INCREF(obj);
7670 return Py_BuildValue((char *)"");
7671 }
7672 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7673 PyObject *resultobj;
7674 wxString *arg1 = 0 ;
7675 wxString const &arg2_defvalue = wxPyEmptyString ;
7676 wxString *arg2 = (wxString *) &arg2_defvalue ;
7677 wxSingleInstanceChecker *result;
7678 bool temp1 = false ;
7679 bool temp2 = false ;
7680 PyObject * obj0 = 0 ;
7681 PyObject * obj1 = 0 ;
7682 char *kwnames[] = {
7683 (char *) "name",(char *) "path", NULL
7684 };
7685
7686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7687 {
7688 arg1 = wxString_in_helper(obj0);
7689 if (arg1 == NULL) SWIG_fail;
7690 temp1 = true;
7691 }
7692 if (obj1) {
7693 {
7694 arg2 = wxString_in_helper(obj1);
7695 if (arg2 == NULL) SWIG_fail;
7696 temp2 = true;
7697 }
7698 }
7699 {
7700 PyThreadState* __tstate = wxPyBeginAllowThreads();
7701 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7702
7703 wxPyEndAllowThreads(__tstate);
7704 if (PyErr_Occurred()) SWIG_fail;
7705 }
7706 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7707 {
7708 if (temp1)
7709 delete arg1;
7710 }
7711 {
7712 if (temp2)
7713 delete arg2;
7714 }
7715 return resultobj;
7716 fail:
7717 {
7718 if (temp1)
7719 delete arg1;
7720 }
7721 {
7722 if (temp2)
7723 delete arg2;
7724 }
7725 return NULL;
7726 }
7727
7728
7729 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7730 PyObject *resultobj;
7731 wxSingleInstanceChecker *result;
7732 char *kwnames[] = {
7733 NULL
7734 };
7735
7736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7737 {
7738 PyThreadState* __tstate = wxPyBeginAllowThreads();
7739 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7740
7741 wxPyEndAllowThreads(__tstate);
7742 if (PyErr_Occurred()) SWIG_fail;
7743 }
7744 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7745 return resultobj;
7746 fail:
7747 return NULL;
7748 }
7749
7750
7751 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7752 PyObject *resultobj;
7753 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7754 PyObject * obj0 = 0 ;
7755 char *kwnames[] = {
7756 (char *) "self", NULL
7757 };
7758
7759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7761 if (SWIG_arg_fail(1)) SWIG_fail;
7762 {
7763 PyThreadState* __tstate = wxPyBeginAllowThreads();
7764 delete arg1;
7765
7766 wxPyEndAllowThreads(__tstate);
7767 if (PyErr_Occurred()) SWIG_fail;
7768 }
7769 Py_INCREF(Py_None); resultobj = Py_None;
7770 return resultobj;
7771 fail:
7772 return NULL;
7773 }
7774
7775
7776 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7777 PyObject *resultobj;
7778 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7779 wxString *arg2 = 0 ;
7780 wxString const &arg3_defvalue = wxPyEmptyString ;
7781 wxString *arg3 = (wxString *) &arg3_defvalue ;
7782 bool result;
7783 bool temp2 = false ;
7784 bool temp3 = false ;
7785 PyObject * obj0 = 0 ;
7786 PyObject * obj1 = 0 ;
7787 PyObject * obj2 = 0 ;
7788 char *kwnames[] = {
7789 (char *) "self",(char *) "name",(char *) "path", NULL
7790 };
7791
7792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7794 if (SWIG_arg_fail(1)) SWIG_fail;
7795 {
7796 arg2 = wxString_in_helper(obj1);
7797 if (arg2 == NULL) SWIG_fail;
7798 temp2 = true;
7799 }
7800 if (obj2) {
7801 {
7802 arg3 = wxString_in_helper(obj2);
7803 if (arg3 == NULL) SWIG_fail;
7804 temp3 = true;
7805 }
7806 }
7807 {
7808 PyThreadState* __tstate = wxPyBeginAllowThreads();
7809 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7810
7811 wxPyEndAllowThreads(__tstate);
7812 if (PyErr_Occurred()) SWIG_fail;
7813 }
7814 {
7815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7816 }
7817 {
7818 if (temp2)
7819 delete arg2;
7820 }
7821 {
7822 if (temp3)
7823 delete arg3;
7824 }
7825 return resultobj;
7826 fail:
7827 {
7828 if (temp2)
7829 delete arg2;
7830 }
7831 {
7832 if (temp3)
7833 delete arg3;
7834 }
7835 return NULL;
7836 }
7837
7838
7839 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7840 PyObject *resultobj;
7841 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7842 bool result;
7843 PyObject * obj0 = 0 ;
7844 char *kwnames[] = {
7845 (char *) "self", NULL
7846 };
7847
7848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7850 if (SWIG_arg_fail(1)) SWIG_fail;
7851 {
7852 PyThreadState* __tstate = wxPyBeginAllowThreads();
7853 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7854
7855 wxPyEndAllowThreads(__tstate);
7856 if (PyErr_Occurred()) SWIG_fail;
7857 }
7858 {
7859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7860 }
7861 return resultobj;
7862 fail:
7863 return NULL;
7864 }
7865
7866
7867 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7868 PyObject *obj;
7869 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7870 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7871 Py_INCREF(obj);
7872 return Py_BuildValue((char *)"");
7873 }
7874 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7875 PyObject *resultobj;
7876 wxWindow *arg1 = (wxWindow *) 0 ;
7877 wxDC *arg2 = 0 ;
7878 bool result;
7879 PyObject * obj0 = 0 ;
7880 PyObject * obj1 = 0 ;
7881 char *kwnames[] = {
7882 (char *) "window",(char *) "dc", NULL
7883 };
7884
7885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7887 if (SWIG_arg_fail(1)) SWIG_fail;
7888 {
7889 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7890 if (SWIG_arg_fail(2)) SWIG_fail;
7891 if (arg2 == NULL) {
7892 SWIG_null_ref("wxDC");
7893 }
7894 if (SWIG_arg_fail(2)) SWIG_fail;
7895 }
7896 {
7897 PyThreadState* __tstate = wxPyBeginAllowThreads();
7898 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7899
7900 wxPyEndAllowThreads(__tstate);
7901 if (PyErr_Occurred()) SWIG_fail;
7902 }
7903 {
7904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7905 }
7906 return resultobj;
7907 fail:
7908 return NULL;
7909 }
7910
7911
7912 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7913 PyObject *resultobj;
7914 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7915 PyObject * obj0 = 0 ;
7916 char *kwnames[] = {
7917 (char *) "self", NULL
7918 };
7919
7920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7922 if (SWIG_arg_fail(1)) SWIG_fail;
7923 {
7924 PyThreadState* __tstate = wxPyBeginAllowThreads();
7925 delete arg1;
7926
7927 wxPyEndAllowThreads(__tstate);
7928 if (PyErr_Occurred()) SWIG_fail;
7929 }
7930 Py_INCREF(Py_None); resultobj = Py_None;
7931 return resultobj;
7932 fail:
7933 return NULL;
7934 }
7935
7936
7937 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7938 PyObject *resultobj;
7939 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7940 wxString result;
7941 PyObject * obj0 = 0 ;
7942 char *kwnames[] = {
7943 (char *) "self", NULL
7944 };
7945
7946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7948 if (SWIG_arg_fail(1)) SWIG_fail;
7949 {
7950 PyThreadState* __tstate = wxPyBeginAllowThreads();
7951 result = (arg1)->GetTip();
7952
7953 wxPyEndAllowThreads(__tstate);
7954 if (PyErr_Occurred()) SWIG_fail;
7955 }
7956 {
7957 #if wxUSE_UNICODE
7958 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7959 #else
7960 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7961 #endif
7962 }
7963 return resultobj;
7964 fail:
7965 return NULL;
7966 }
7967
7968
7969 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7970 PyObject *resultobj;
7971 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7972 size_t result;
7973 PyObject * obj0 = 0 ;
7974 char *kwnames[] = {
7975 (char *) "self", NULL
7976 };
7977
7978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7980 if (SWIG_arg_fail(1)) SWIG_fail;
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 result = (size_t)(arg1)->GetCurrentTip();
7984
7985 wxPyEndAllowThreads(__tstate);
7986 if (PyErr_Occurred()) SWIG_fail;
7987 }
7988 {
7989 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7990 }
7991 return resultobj;
7992 fail:
7993 return NULL;
7994 }
7995
7996
7997 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7998 PyObject *resultobj;
7999 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8000 wxString *arg2 = 0 ;
8001 wxString result;
8002 bool temp2 = false ;
8003 PyObject * obj0 = 0 ;
8004 PyObject * obj1 = 0 ;
8005 char *kwnames[] = {
8006 (char *) "self",(char *) "tip", NULL
8007 };
8008
8009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8011 if (SWIG_arg_fail(1)) SWIG_fail;
8012 {
8013 arg2 = wxString_in_helper(obj1);
8014 if (arg2 == NULL) SWIG_fail;
8015 temp2 = true;
8016 }
8017 {
8018 PyThreadState* __tstate = wxPyBeginAllowThreads();
8019 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8020
8021 wxPyEndAllowThreads(__tstate);
8022 if (PyErr_Occurred()) SWIG_fail;
8023 }
8024 {
8025 #if wxUSE_UNICODE
8026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8027 #else
8028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8029 #endif
8030 }
8031 {
8032 if (temp2)
8033 delete arg2;
8034 }
8035 return resultobj;
8036 fail:
8037 {
8038 if (temp2)
8039 delete arg2;
8040 }
8041 return NULL;
8042 }
8043
8044
8045 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8046 PyObject *obj;
8047 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8048 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8049 Py_INCREF(obj);
8050 return Py_BuildValue((char *)"");
8051 }
8052 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8053 PyObject *resultobj;
8054 size_t arg1 ;
8055 wxPyTipProvider *result;
8056 PyObject * obj0 = 0 ;
8057 char *kwnames[] = {
8058 (char *) "currentTip", NULL
8059 };
8060
8061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8062 {
8063 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8064 if (SWIG_arg_fail(1)) SWIG_fail;
8065 }
8066 {
8067 PyThreadState* __tstate = wxPyBeginAllowThreads();
8068 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8069
8070 wxPyEndAllowThreads(__tstate);
8071 if (PyErr_Occurred()) SWIG_fail;
8072 }
8073 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8074 return resultobj;
8075 fail:
8076 return NULL;
8077 }
8078
8079
8080 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8081 PyObject *resultobj;
8082 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8083 PyObject *arg2 = (PyObject *) 0 ;
8084 PyObject *arg3 = (PyObject *) 0 ;
8085 PyObject * obj0 = 0 ;
8086 PyObject * obj1 = 0 ;
8087 PyObject * obj2 = 0 ;
8088 char *kwnames[] = {
8089 (char *) "self",(char *) "self",(char *) "_class", NULL
8090 };
8091
8092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8094 if (SWIG_arg_fail(1)) SWIG_fail;
8095 arg2 = obj1;
8096 arg3 = obj2;
8097 {
8098 PyThreadState* __tstate = wxPyBeginAllowThreads();
8099 (arg1)->_setCallbackInfo(arg2,arg3);
8100
8101 wxPyEndAllowThreads(__tstate);
8102 if (PyErr_Occurred()) SWIG_fail;
8103 }
8104 Py_INCREF(Py_None); resultobj = Py_None;
8105 return resultobj;
8106 fail:
8107 return NULL;
8108 }
8109
8110
8111 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8112 PyObject *obj;
8113 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8114 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8115 Py_INCREF(obj);
8116 return Py_BuildValue((char *)"");
8117 }
8118 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8119 PyObject *resultobj;
8120 wxWindow *arg1 = (wxWindow *) 0 ;
8121 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8122 bool arg3 = (bool) true ;
8123 bool result;
8124 PyObject * obj0 = 0 ;
8125 PyObject * obj1 = 0 ;
8126 PyObject * obj2 = 0 ;
8127 char *kwnames[] = {
8128 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8129 };
8130
8131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8133 if (SWIG_arg_fail(1)) SWIG_fail;
8134 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8135 if (SWIG_arg_fail(2)) SWIG_fail;
8136 if (obj2) {
8137 {
8138 arg3 = (bool)(SWIG_As_bool(obj2));
8139 if (SWIG_arg_fail(3)) SWIG_fail;
8140 }
8141 }
8142 {
8143 if (!wxPyCheckForApp()) SWIG_fail;
8144 PyThreadState* __tstate = wxPyBeginAllowThreads();
8145 result = (bool)wxShowTip(arg1,arg2,arg3);
8146
8147 wxPyEndAllowThreads(__tstate);
8148 if (PyErr_Occurred()) SWIG_fail;
8149 }
8150 {
8151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8152 }
8153 return resultobj;
8154 fail:
8155 return NULL;
8156 }
8157
8158
8159 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8160 PyObject *resultobj;
8161 wxString *arg1 = 0 ;
8162 size_t arg2 ;
8163 wxTipProvider *result;
8164 bool temp1 = false ;
8165 PyObject * obj0 = 0 ;
8166 PyObject * obj1 = 0 ;
8167 char *kwnames[] = {
8168 (char *) "filename",(char *) "currentTip", NULL
8169 };
8170
8171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8172 {
8173 arg1 = wxString_in_helper(obj0);
8174 if (arg1 == NULL) SWIG_fail;
8175 temp1 = true;
8176 }
8177 {
8178 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8179 if (SWIG_arg_fail(2)) SWIG_fail;
8180 }
8181 {
8182 if (!wxPyCheckForApp()) SWIG_fail;
8183 PyThreadState* __tstate = wxPyBeginAllowThreads();
8184 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8185
8186 wxPyEndAllowThreads(__tstate);
8187 if (PyErr_Occurred()) SWIG_fail;
8188 }
8189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8190 {
8191 if (temp1)
8192 delete arg1;
8193 }
8194 return resultobj;
8195 fail:
8196 {
8197 if (temp1)
8198 delete arg1;
8199 }
8200 return NULL;
8201 }
8202
8203
8204 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8205 PyObject *resultobj;
8206 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8207 int arg2 = (int) -1 ;
8208 wxPyTimer *result;
8209 PyObject * obj0 = 0 ;
8210 PyObject * obj1 = 0 ;
8211 char *kwnames[] = {
8212 (char *) "owner",(char *) "id", NULL
8213 };
8214
8215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8216 if (obj0) {
8217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8218 if (SWIG_arg_fail(1)) SWIG_fail;
8219 }
8220 if (obj1) {
8221 {
8222 arg2 = (int)(SWIG_As_int(obj1));
8223 if (SWIG_arg_fail(2)) SWIG_fail;
8224 }
8225 }
8226 {
8227 if (!wxPyCheckForApp()) SWIG_fail;
8228 PyThreadState* __tstate = wxPyBeginAllowThreads();
8229 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8230
8231 wxPyEndAllowThreads(__tstate);
8232 if (PyErr_Occurred()) SWIG_fail;
8233 }
8234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8235 return resultobj;
8236 fail:
8237 return NULL;
8238 }
8239
8240
8241 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8242 PyObject *resultobj;
8243 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8244 PyObject * obj0 = 0 ;
8245 char *kwnames[] = {
8246 (char *) "self", NULL
8247 };
8248
8249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8251 if (SWIG_arg_fail(1)) SWIG_fail;
8252 {
8253 PyThreadState* __tstate = wxPyBeginAllowThreads();
8254 delete arg1;
8255
8256 wxPyEndAllowThreads(__tstate);
8257 if (PyErr_Occurred()) SWIG_fail;
8258 }
8259 Py_INCREF(Py_None); resultobj = Py_None;
8260 return resultobj;
8261 fail:
8262 return NULL;
8263 }
8264
8265
8266 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8267 PyObject *resultobj;
8268 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8269 PyObject *arg2 = (PyObject *) 0 ;
8270 PyObject *arg3 = (PyObject *) 0 ;
8271 int arg4 = (int) 1 ;
8272 PyObject * obj0 = 0 ;
8273 PyObject * obj1 = 0 ;
8274 PyObject * obj2 = 0 ;
8275 PyObject * obj3 = 0 ;
8276 char *kwnames[] = {
8277 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8278 };
8279
8280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8282 if (SWIG_arg_fail(1)) SWIG_fail;
8283 arg2 = obj1;
8284 arg3 = obj2;
8285 if (obj3) {
8286 {
8287 arg4 = (int)(SWIG_As_int(obj3));
8288 if (SWIG_arg_fail(4)) SWIG_fail;
8289 }
8290 }
8291 {
8292 PyThreadState* __tstate = wxPyBeginAllowThreads();
8293 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8294
8295 wxPyEndAllowThreads(__tstate);
8296 if (PyErr_Occurred()) SWIG_fail;
8297 }
8298 Py_INCREF(Py_None); resultobj = Py_None;
8299 return resultobj;
8300 fail:
8301 return NULL;
8302 }
8303
8304
8305 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8306 PyObject *resultobj;
8307 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8308 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8309 int arg3 = (int) -1 ;
8310 PyObject * obj0 = 0 ;
8311 PyObject * obj1 = 0 ;
8312 PyObject * obj2 = 0 ;
8313 char *kwnames[] = {
8314 (char *) "self",(char *) "owner",(char *) "id", NULL
8315 };
8316
8317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8319 if (SWIG_arg_fail(1)) SWIG_fail;
8320 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8321 if (SWIG_arg_fail(2)) SWIG_fail;
8322 if (obj2) {
8323 {
8324 arg3 = (int)(SWIG_As_int(obj2));
8325 if (SWIG_arg_fail(3)) SWIG_fail;
8326 }
8327 }
8328 {
8329 PyThreadState* __tstate = wxPyBeginAllowThreads();
8330 (arg1)->SetOwner(arg2,arg3);
8331
8332 wxPyEndAllowThreads(__tstate);
8333 if (PyErr_Occurred()) SWIG_fail;
8334 }
8335 Py_INCREF(Py_None); resultobj = Py_None;
8336 return resultobj;
8337 fail:
8338 return NULL;
8339 }
8340
8341
8342 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8343 PyObject *resultobj;
8344 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8345 wxEvtHandler *result;
8346 PyObject * obj0 = 0 ;
8347 char *kwnames[] = {
8348 (char *) "self", NULL
8349 };
8350
8351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8353 if (SWIG_arg_fail(1)) SWIG_fail;
8354 {
8355 PyThreadState* __tstate = wxPyBeginAllowThreads();
8356 result = (wxEvtHandler *)(arg1)->GetOwner();
8357
8358 wxPyEndAllowThreads(__tstate);
8359 if (PyErr_Occurred()) SWIG_fail;
8360 }
8361 {
8362 resultobj = wxPyMake_wxObject(result, 0);
8363 }
8364 return resultobj;
8365 fail:
8366 return NULL;
8367 }
8368
8369
8370 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8371 PyObject *resultobj;
8372 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8373 int arg2 = (int) -1 ;
8374 bool arg3 = (bool) false ;
8375 bool result;
8376 PyObject * obj0 = 0 ;
8377 PyObject * obj1 = 0 ;
8378 PyObject * obj2 = 0 ;
8379 char *kwnames[] = {
8380 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8381 };
8382
8383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8385 if (SWIG_arg_fail(1)) SWIG_fail;
8386 if (obj1) {
8387 {
8388 arg2 = (int)(SWIG_As_int(obj1));
8389 if (SWIG_arg_fail(2)) SWIG_fail;
8390 }
8391 }
8392 if (obj2) {
8393 {
8394 arg3 = (bool)(SWIG_As_bool(obj2));
8395 if (SWIG_arg_fail(3)) SWIG_fail;
8396 }
8397 }
8398 {
8399 PyThreadState* __tstate = wxPyBeginAllowThreads();
8400 result = (bool)(arg1)->Start(arg2,arg3);
8401
8402 wxPyEndAllowThreads(__tstate);
8403 if (PyErr_Occurred()) SWIG_fail;
8404 }
8405 {
8406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8407 }
8408 return resultobj;
8409 fail:
8410 return NULL;
8411 }
8412
8413
8414 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8415 PyObject *resultobj;
8416 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8417 PyObject * obj0 = 0 ;
8418 char *kwnames[] = {
8419 (char *) "self", NULL
8420 };
8421
8422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8424 if (SWIG_arg_fail(1)) SWIG_fail;
8425 {
8426 PyThreadState* __tstate = wxPyBeginAllowThreads();
8427 (arg1)->Stop();
8428
8429 wxPyEndAllowThreads(__tstate);
8430 if (PyErr_Occurred()) SWIG_fail;
8431 }
8432 Py_INCREF(Py_None); resultobj = Py_None;
8433 return resultobj;
8434 fail:
8435 return NULL;
8436 }
8437
8438
8439 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8440 PyObject *resultobj;
8441 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8442 bool result;
8443 PyObject * obj0 = 0 ;
8444 char *kwnames[] = {
8445 (char *) "self", NULL
8446 };
8447
8448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8450 if (SWIG_arg_fail(1)) SWIG_fail;
8451 {
8452 PyThreadState* __tstate = wxPyBeginAllowThreads();
8453 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8454
8455 wxPyEndAllowThreads(__tstate);
8456 if (PyErr_Occurred()) SWIG_fail;
8457 }
8458 {
8459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8460 }
8461 return resultobj;
8462 fail:
8463 return NULL;
8464 }
8465
8466
8467 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8468 PyObject *resultobj;
8469 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8470 int result;
8471 PyObject * obj0 = 0 ;
8472 char *kwnames[] = {
8473 (char *) "self", NULL
8474 };
8475
8476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8478 if (SWIG_arg_fail(1)) SWIG_fail;
8479 {
8480 PyThreadState* __tstate = wxPyBeginAllowThreads();
8481 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8482
8483 wxPyEndAllowThreads(__tstate);
8484 if (PyErr_Occurred()) SWIG_fail;
8485 }
8486 {
8487 resultobj = SWIG_From_int((int)(result));
8488 }
8489 return resultobj;
8490 fail:
8491 return NULL;
8492 }
8493
8494
8495 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8496 PyObject *resultobj;
8497 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8498 bool result;
8499 PyObject * obj0 = 0 ;
8500 char *kwnames[] = {
8501 (char *) "self", NULL
8502 };
8503
8504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8506 if (SWIG_arg_fail(1)) SWIG_fail;
8507 {
8508 PyThreadState* __tstate = wxPyBeginAllowThreads();
8509 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8510
8511 wxPyEndAllowThreads(__tstate);
8512 if (PyErr_Occurred()) SWIG_fail;
8513 }
8514 {
8515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8516 }
8517 return resultobj;
8518 fail:
8519 return NULL;
8520 }
8521
8522
8523 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8524 PyObject *resultobj;
8525 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8526 int result;
8527 PyObject * obj0 = 0 ;
8528 char *kwnames[] = {
8529 (char *) "self", NULL
8530 };
8531
8532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8534 if (SWIG_arg_fail(1)) SWIG_fail;
8535 {
8536 PyThreadState* __tstate = wxPyBeginAllowThreads();
8537 result = (int)((wxPyTimer const *)arg1)->GetId();
8538
8539 wxPyEndAllowThreads(__tstate);
8540 if (PyErr_Occurred()) SWIG_fail;
8541 }
8542 {
8543 resultobj = SWIG_From_int((int)(result));
8544 }
8545 return resultobj;
8546 fail:
8547 return NULL;
8548 }
8549
8550
8551 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8552 PyObject *obj;
8553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8554 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8555 Py_INCREF(obj);
8556 return Py_BuildValue((char *)"");
8557 }
8558 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8559 PyObject *resultobj;
8560 int arg1 = (int) 0 ;
8561 int arg2 = (int) 0 ;
8562 wxTimerEvent *result;
8563 PyObject * obj0 = 0 ;
8564 PyObject * obj1 = 0 ;
8565 char *kwnames[] = {
8566 (char *) "timerid",(char *) "interval", NULL
8567 };
8568
8569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8570 if (obj0) {
8571 {
8572 arg1 = (int)(SWIG_As_int(obj0));
8573 if (SWIG_arg_fail(1)) SWIG_fail;
8574 }
8575 }
8576 if (obj1) {
8577 {
8578 arg2 = (int)(SWIG_As_int(obj1));
8579 if (SWIG_arg_fail(2)) SWIG_fail;
8580 }
8581 }
8582 {
8583 PyThreadState* __tstate = wxPyBeginAllowThreads();
8584 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8585
8586 wxPyEndAllowThreads(__tstate);
8587 if (PyErr_Occurred()) SWIG_fail;
8588 }
8589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8590 return resultobj;
8591 fail:
8592 return NULL;
8593 }
8594
8595
8596 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8597 PyObject *resultobj;
8598 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8599 int result;
8600 PyObject * obj0 = 0 ;
8601 char *kwnames[] = {
8602 (char *) "self", NULL
8603 };
8604
8605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8607 if (SWIG_arg_fail(1)) SWIG_fail;
8608 {
8609 PyThreadState* __tstate = wxPyBeginAllowThreads();
8610 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8611
8612 wxPyEndAllowThreads(__tstate);
8613 if (PyErr_Occurred()) SWIG_fail;
8614 }
8615 {
8616 resultobj = SWIG_From_int((int)(result));
8617 }
8618 return resultobj;
8619 fail:
8620 return NULL;
8621 }
8622
8623
8624 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8625 PyObject *obj;
8626 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8627 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8628 Py_INCREF(obj);
8629 return Py_BuildValue((char *)"");
8630 }
8631 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8632 PyObject *resultobj;
8633 wxTimer *arg1 = 0 ;
8634 wxTimerRunner *result;
8635 PyObject * obj0 = 0 ;
8636
8637 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8638 {
8639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8640 if (SWIG_arg_fail(1)) SWIG_fail;
8641 if (arg1 == NULL) {
8642 SWIG_null_ref("wxTimer");
8643 }
8644 if (SWIG_arg_fail(1)) SWIG_fail;
8645 }
8646 {
8647 if (!wxPyCheckForApp()) SWIG_fail;
8648 PyThreadState* __tstate = wxPyBeginAllowThreads();
8649 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8650
8651 wxPyEndAllowThreads(__tstate);
8652 if (PyErr_Occurred()) SWIG_fail;
8653 }
8654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8655 return resultobj;
8656 fail:
8657 return NULL;
8658 }
8659
8660
8661 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8662 PyObject *resultobj;
8663 wxTimer *arg1 = 0 ;
8664 int arg2 ;
8665 bool arg3 = (bool) false ;
8666 wxTimerRunner *result;
8667 PyObject * obj0 = 0 ;
8668 PyObject * obj1 = 0 ;
8669 PyObject * obj2 = 0 ;
8670
8671 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8672 {
8673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8674 if (SWIG_arg_fail(1)) SWIG_fail;
8675 if (arg1 == NULL) {
8676 SWIG_null_ref("wxTimer");
8677 }
8678 if (SWIG_arg_fail(1)) SWIG_fail;
8679 }
8680 {
8681 arg2 = (int)(SWIG_As_int(obj1));
8682 if (SWIG_arg_fail(2)) SWIG_fail;
8683 }
8684 if (obj2) {
8685 {
8686 arg3 = (bool)(SWIG_As_bool(obj2));
8687 if (SWIG_arg_fail(3)) SWIG_fail;
8688 }
8689 }
8690 {
8691 if (!wxPyCheckForApp()) SWIG_fail;
8692 PyThreadState* __tstate = wxPyBeginAllowThreads();
8693 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8694
8695 wxPyEndAllowThreads(__tstate);
8696 if (PyErr_Occurred()) SWIG_fail;
8697 }
8698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8699 return resultobj;
8700 fail:
8701 return NULL;
8702 }
8703
8704
8705 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8706 int argc;
8707 PyObject *argv[4];
8708 int ii;
8709
8710 argc = PyObject_Length(args);
8711 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8712 argv[ii] = PyTuple_GetItem(args,ii);
8713 }
8714 if (argc == 1) {
8715 int _v;
8716 {
8717 void *ptr = 0;
8718 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8719 _v = 0;
8720 PyErr_Clear();
8721 } else {
8722 _v = (ptr != 0);
8723 }
8724 }
8725 if (_v) {
8726 return _wrap_new_TimerRunner__SWIG_0(self,args);
8727 }
8728 }
8729 if ((argc >= 2) && (argc <= 3)) {
8730 int _v;
8731 {
8732 void *ptr = 0;
8733 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8734 _v = 0;
8735 PyErr_Clear();
8736 } else {
8737 _v = (ptr != 0);
8738 }
8739 }
8740 if (_v) {
8741 _v = SWIG_Check_int(argv[1]);
8742 if (_v) {
8743 if (argc <= 2) {
8744 return _wrap_new_TimerRunner__SWIG_1(self,args);
8745 }
8746 _v = SWIG_Check_bool(argv[2]);
8747 if (_v) {
8748 return _wrap_new_TimerRunner__SWIG_1(self,args);
8749 }
8750 }
8751 }
8752 }
8753
8754 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8755 return NULL;
8756 }
8757
8758
8759 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8760 PyObject *resultobj;
8761 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8762 PyObject * obj0 = 0 ;
8763 char *kwnames[] = {
8764 (char *) "self", NULL
8765 };
8766
8767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8769 if (SWIG_arg_fail(1)) SWIG_fail;
8770 {
8771 PyThreadState* __tstate = wxPyBeginAllowThreads();
8772 delete arg1;
8773
8774 wxPyEndAllowThreads(__tstate);
8775 if (PyErr_Occurred()) SWIG_fail;
8776 }
8777 Py_INCREF(Py_None); resultobj = Py_None;
8778 return resultobj;
8779 fail:
8780 return NULL;
8781 }
8782
8783
8784 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8785 PyObject *resultobj;
8786 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8787 int arg2 ;
8788 bool arg3 = (bool) false ;
8789 PyObject * obj0 = 0 ;
8790 PyObject * obj1 = 0 ;
8791 PyObject * obj2 = 0 ;
8792 char *kwnames[] = {
8793 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8794 };
8795
8796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8798 if (SWIG_arg_fail(1)) SWIG_fail;
8799 {
8800 arg2 = (int)(SWIG_As_int(obj1));
8801 if (SWIG_arg_fail(2)) SWIG_fail;
8802 }
8803 if (obj2) {
8804 {
8805 arg3 = (bool)(SWIG_As_bool(obj2));
8806 if (SWIG_arg_fail(3)) SWIG_fail;
8807 }
8808 }
8809 {
8810 PyThreadState* __tstate = wxPyBeginAllowThreads();
8811 (arg1)->Start(arg2,arg3);
8812
8813 wxPyEndAllowThreads(__tstate);
8814 if (PyErr_Occurred()) SWIG_fail;
8815 }
8816 Py_INCREF(Py_None); resultobj = Py_None;
8817 return resultobj;
8818 fail:
8819 return NULL;
8820 }
8821
8822
8823 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8824 PyObject *obj;
8825 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8826 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8827 Py_INCREF(obj);
8828 return Py_BuildValue((char *)"");
8829 }
8830 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8831 PyObject *resultobj;
8832 wxLog *result;
8833 char *kwnames[] = {
8834 NULL
8835 };
8836
8837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8838 {
8839 PyThreadState* __tstate = wxPyBeginAllowThreads();
8840 result = (wxLog *)new wxLog();
8841
8842 wxPyEndAllowThreads(__tstate);
8843 if (PyErr_Occurred()) SWIG_fail;
8844 }
8845 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8846 return resultobj;
8847 fail:
8848 return NULL;
8849 }
8850
8851
8852 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8853 PyObject *resultobj;
8854 bool result;
8855 char *kwnames[] = {
8856 NULL
8857 };
8858
8859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8860 {
8861 PyThreadState* __tstate = wxPyBeginAllowThreads();
8862 result = (bool)wxLog::IsEnabled();
8863
8864 wxPyEndAllowThreads(__tstate);
8865 if (PyErr_Occurred()) SWIG_fail;
8866 }
8867 {
8868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8869 }
8870 return resultobj;
8871 fail:
8872 return NULL;
8873 }
8874
8875
8876 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8877 PyObject *resultobj;
8878 bool arg1 = (bool) true ;
8879 bool result;
8880 PyObject * obj0 = 0 ;
8881 char *kwnames[] = {
8882 (char *) "doIt", NULL
8883 };
8884
8885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8886 if (obj0) {
8887 {
8888 arg1 = (bool)(SWIG_As_bool(obj0));
8889 if (SWIG_arg_fail(1)) SWIG_fail;
8890 }
8891 }
8892 {
8893 PyThreadState* __tstate = wxPyBeginAllowThreads();
8894 result = (bool)wxLog::EnableLogging(arg1);
8895
8896 wxPyEndAllowThreads(__tstate);
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 {
8900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8901 }
8902 return resultobj;
8903 fail:
8904 return NULL;
8905 }
8906
8907
8908 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8909 PyObject *resultobj;
8910 wxLogLevel arg1 ;
8911 wxChar *arg2 = (wxChar *) 0 ;
8912 time_t arg3 ;
8913 PyObject * obj0 = 0 ;
8914 PyObject * obj1 = 0 ;
8915 PyObject * obj2 = 0 ;
8916 char *kwnames[] = {
8917 (char *) "level",(char *) "szString",(char *) "t", NULL
8918 };
8919
8920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8921 {
8922 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8923 if (SWIG_arg_fail(1)) SWIG_fail;
8924 }
8925 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8926 if (SWIG_arg_fail(2)) SWIG_fail;
8927 {
8928 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8929 if (SWIG_arg_fail(3)) SWIG_fail;
8930 }
8931 {
8932 PyThreadState* __tstate = wxPyBeginAllowThreads();
8933 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8934
8935 wxPyEndAllowThreads(__tstate);
8936 if (PyErr_Occurred()) SWIG_fail;
8937 }
8938 Py_INCREF(Py_None); resultobj = Py_None;
8939 return resultobj;
8940 fail:
8941 return NULL;
8942 }
8943
8944
8945 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8946 PyObject *resultobj;
8947 wxLog *arg1 = (wxLog *) 0 ;
8948 PyObject * obj0 = 0 ;
8949 char *kwnames[] = {
8950 (char *) "self", NULL
8951 };
8952
8953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8955 if (SWIG_arg_fail(1)) SWIG_fail;
8956 {
8957 PyThreadState* __tstate = wxPyBeginAllowThreads();
8958 (arg1)->Flush();
8959
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 Py_INCREF(Py_None); resultobj = Py_None;
8964 return resultobj;
8965 fail:
8966 return NULL;
8967 }
8968
8969
8970 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8971 PyObject *resultobj;
8972 char *kwnames[] = {
8973 NULL
8974 };
8975
8976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8977 {
8978 PyThreadState* __tstate = wxPyBeginAllowThreads();
8979 wxLog::FlushActive();
8980
8981 wxPyEndAllowThreads(__tstate);
8982 if (PyErr_Occurred()) SWIG_fail;
8983 }
8984 Py_INCREF(Py_None); resultobj = Py_None;
8985 return resultobj;
8986 fail:
8987 return NULL;
8988 }
8989
8990
8991 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8992 PyObject *resultobj;
8993 wxLog *result;
8994 char *kwnames[] = {
8995 NULL
8996 };
8997
8998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8999 {
9000 PyThreadState* __tstate = wxPyBeginAllowThreads();
9001 result = (wxLog *)wxLog::GetActiveTarget();
9002
9003 wxPyEndAllowThreads(__tstate);
9004 if (PyErr_Occurred()) SWIG_fail;
9005 }
9006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9007 return resultobj;
9008 fail:
9009 return NULL;
9010 }
9011
9012
9013 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9014 PyObject *resultobj;
9015 wxLog *arg1 = (wxLog *) 0 ;
9016 wxLog *result;
9017 PyObject * obj0 = 0 ;
9018 char *kwnames[] = {
9019 (char *) "pLogger", NULL
9020 };
9021
9022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9024 if (SWIG_arg_fail(1)) SWIG_fail;
9025 {
9026 PyThreadState* __tstate = wxPyBeginAllowThreads();
9027 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9028
9029 wxPyEndAllowThreads(__tstate);
9030 if (PyErr_Occurred()) SWIG_fail;
9031 }
9032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9033 return resultobj;
9034 fail:
9035 return NULL;
9036 }
9037
9038
9039 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9040 PyObject *resultobj;
9041 char *kwnames[] = {
9042 NULL
9043 };
9044
9045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9046 {
9047 PyThreadState* __tstate = wxPyBeginAllowThreads();
9048 wxLog::Suspend();
9049
9050 wxPyEndAllowThreads(__tstate);
9051 if (PyErr_Occurred()) SWIG_fail;
9052 }
9053 Py_INCREF(Py_None); resultobj = Py_None;
9054 return resultobj;
9055 fail:
9056 return NULL;
9057 }
9058
9059
9060 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9061 PyObject *resultobj;
9062 char *kwnames[] = {
9063 NULL
9064 };
9065
9066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9067 {
9068 PyThreadState* __tstate = wxPyBeginAllowThreads();
9069 wxLog::Resume();
9070
9071 wxPyEndAllowThreads(__tstate);
9072 if (PyErr_Occurred()) SWIG_fail;
9073 }
9074 Py_INCREF(Py_None); resultobj = Py_None;
9075 return resultobj;
9076 fail:
9077 return NULL;
9078 }
9079
9080
9081 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9082 PyObject *resultobj;
9083 bool arg1 = (bool) true ;
9084 PyObject * obj0 = 0 ;
9085 char *kwnames[] = {
9086 (char *) "bVerbose", NULL
9087 };
9088
9089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9090 if (obj0) {
9091 {
9092 arg1 = (bool)(SWIG_As_bool(obj0));
9093 if (SWIG_arg_fail(1)) SWIG_fail;
9094 }
9095 }
9096 {
9097 PyThreadState* __tstate = wxPyBeginAllowThreads();
9098 wxLog::SetVerbose(arg1);
9099
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 Py_INCREF(Py_None); resultobj = Py_None;
9104 return resultobj;
9105 fail:
9106 return NULL;
9107 }
9108
9109
9110 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9111 PyObject *resultobj;
9112 wxLogLevel arg1 ;
9113 PyObject * obj0 = 0 ;
9114 char *kwnames[] = {
9115 (char *) "logLevel", NULL
9116 };
9117
9118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9119 {
9120 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9121 if (SWIG_arg_fail(1)) SWIG_fail;
9122 }
9123 {
9124 PyThreadState* __tstate = wxPyBeginAllowThreads();
9125 wxLog::SetLogLevel(arg1);
9126
9127 wxPyEndAllowThreads(__tstate);
9128 if (PyErr_Occurred()) SWIG_fail;
9129 }
9130 Py_INCREF(Py_None); resultobj = Py_None;
9131 return resultobj;
9132 fail:
9133 return NULL;
9134 }
9135
9136
9137 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9138 PyObject *resultobj;
9139 char *kwnames[] = {
9140 NULL
9141 };
9142
9143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9144 {
9145 PyThreadState* __tstate = wxPyBeginAllowThreads();
9146 wxLog::DontCreateOnDemand();
9147
9148 wxPyEndAllowThreads(__tstate);
9149 if (PyErr_Occurred()) SWIG_fail;
9150 }
9151 Py_INCREF(Py_None); resultobj = Py_None;
9152 return resultobj;
9153 fail:
9154 return NULL;
9155 }
9156
9157
9158 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9159 PyObject *resultobj;
9160 wxTraceMask arg1 ;
9161 PyObject * obj0 = 0 ;
9162 char *kwnames[] = {
9163 (char *) "ulMask", NULL
9164 };
9165
9166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9167 {
9168 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9169 if (SWIG_arg_fail(1)) SWIG_fail;
9170 }
9171 {
9172 PyThreadState* __tstate = wxPyBeginAllowThreads();
9173 wxLog::SetTraceMask(arg1);
9174
9175 wxPyEndAllowThreads(__tstate);
9176 if (PyErr_Occurred()) SWIG_fail;
9177 }
9178 Py_INCREF(Py_None); resultobj = Py_None;
9179 return resultobj;
9180 fail:
9181 return NULL;
9182 }
9183
9184
9185 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9186 PyObject *resultobj;
9187 wxString *arg1 = 0 ;
9188 bool temp1 = false ;
9189 PyObject * obj0 = 0 ;
9190 char *kwnames[] = {
9191 (char *) "str", NULL
9192 };
9193
9194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9195 {
9196 arg1 = wxString_in_helper(obj0);
9197 if (arg1 == NULL) SWIG_fail;
9198 temp1 = true;
9199 }
9200 {
9201 PyThreadState* __tstate = wxPyBeginAllowThreads();
9202 wxLog::AddTraceMask((wxString const &)*arg1);
9203
9204 wxPyEndAllowThreads(__tstate);
9205 if (PyErr_Occurred()) SWIG_fail;
9206 }
9207 Py_INCREF(Py_None); resultobj = Py_None;
9208 {
9209 if (temp1)
9210 delete arg1;
9211 }
9212 return resultobj;
9213 fail:
9214 {
9215 if (temp1)
9216 delete arg1;
9217 }
9218 return NULL;
9219 }
9220
9221
9222 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9223 PyObject *resultobj;
9224 wxString *arg1 = 0 ;
9225 bool temp1 = false ;
9226 PyObject * obj0 = 0 ;
9227 char *kwnames[] = {
9228 (char *) "str", NULL
9229 };
9230
9231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9232 {
9233 arg1 = wxString_in_helper(obj0);
9234 if (arg1 == NULL) SWIG_fail;
9235 temp1 = true;
9236 }
9237 {
9238 PyThreadState* __tstate = wxPyBeginAllowThreads();
9239 wxLog::RemoveTraceMask((wxString const &)*arg1);
9240
9241 wxPyEndAllowThreads(__tstate);
9242 if (PyErr_Occurred()) SWIG_fail;
9243 }
9244 Py_INCREF(Py_None); resultobj = Py_None;
9245 {
9246 if (temp1)
9247 delete arg1;
9248 }
9249 return resultobj;
9250 fail:
9251 {
9252 if (temp1)
9253 delete arg1;
9254 }
9255 return NULL;
9256 }
9257
9258
9259 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9260 PyObject *resultobj;
9261 char *kwnames[] = {
9262 NULL
9263 };
9264
9265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9266 {
9267 PyThreadState* __tstate = wxPyBeginAllowThreads();
9268 wxLog::ClearTraceMasks();
9269
9270 wxPyEndAllowThreads(__tstate);
9271 if (PyErr_Occurred()) SWIG_fail;
9272 }
9273 Py_INCREF(Py_None); resultobj = Py_None;
9274 return resultobj;
9275 fail:
9276 return NULL;
9277 }
9278
9279
9280 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9281 PyObject *resultobj;
9282 wxArrayString *result;
9283 char *kwnames[] = {
9284 NULL
9285 };
9286
9287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9288 {
9289 PyThreadState* __tstate = wxPyBeginAllowThreads();
9290 {
9291 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9292 result = (wxArrayString *) &_result_ref;
9293 }
9294
9295 wxPyEndAllowThreads(__tstate);
9296 if (PyErr_Occurred()) SWIG_fail;
9297 }
9298 {
9299 resultobj = wxArrayString2PyList_helper(*result);
9300 }
9301 return resultobj;
9302 fail:
9303 return NULL;
9304 }
9305
9306
9307 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9308 PyObject *resultobj;
9309 wxChar *arg1 = (wxChar *) 0 ;
9310 PyObject * obj0 = 0 ;
9311 char *kwnames[] = {
9312 (char *) "ts", NULL
9313 };
9314
9315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9317 if (SWIG_arg_fail(1)) SWIG_fail;
9318 {
9319 PyThreadState* __tstate = wxPyBeginAllowThreads();
9320 wxLog::SetTimestamp((wxChar const *)arg1);
9321
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 Py_INCREF(Py_None); resultobj = Py_None;
9326 return resultobj;
9327 fail:
9328 return NULL;
9329 }
9330
9331
9332 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9333 PyObject *resultobj;
9334 bool result;
9335 char *kwnames[] = {
9336 NULL
9337 };
9338
9339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9340 {
9341 PyThreadState* __tstate = wxPyBeginAllowThreads();
9342 result = (bool)wxLog::GetVerbose();
9343
9344 wxPyEndAllowThreads(__tstate);
9345 if (PyErr_Occurred()) SWIG_fail;
9346 }
9347 {
9348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9349 }
9350 return resultobj;
9351 fail:
9352 return NULL;
9353 }
9354
9355
9356 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9357 PyObject *resultobj;
9358 wxTraceMask result;
9359 char *kwnames[] = {
9360 NULL
9361 };
9362
9363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9364 {
9365 PyThreadState* __tstate = wxPyBeginAllowThreads();
9366 result = (wxTraceMask)wxLog::GetTraceMask();
9367
9368 wxPyEndAllowThreads(__tstate);
9369 if (PyErr_Occurred()) SWIG_fail;
9370 }
9371 {
9372 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9373 }
9374 return resultobj;
9375 fail:
9376 return NULL;
9377 }
9378
9379
9380 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9381 PyObject *resultobj;
9382 wxChar *arg1 = (wxChar *) 0 ;
9383 bool result;
9384 PyObject * obj0 = 0 ;
9385 char *kwnames[] = {
9386 (char *) "mask", NULL
9387 };
9388
9389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9391 if (SWIG_arg_fail(1)) SWIG_fail;
9392 {
9393 PyThreadState* __tstate = wxPyBeginAllowThreads();
9394 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9395
9396 wxPyEndAllowThreads(__tstate);
9397 if (PyErr_Occurred()) SWIG_fail;
9398 }
9399 {
9400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9401 }
9402 return resultobj;
9403 fail:
9404 return NULL;
9405 }
9406
9407
9408 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9409 PyObject *resultobj;
9410 wxLogLevel result;
9411 char *kwnames[] = {
9412 NULL
9413 };
9414
9415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9416 {
9417 PyThreadState* __tstate = wxPyBeginAllowThreads();
9418 result = (wxLogLevel)wxLog::GetLogLevel();
9419
9420 wxPyEndAllowThreads(__tstate);
9421 if (PyErr_Occurred()) SWIG_fail;
9422 }
9423 {
9424 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9425 }
9426 return resultobj;
9427 fail:
9428 return NULL;
9429 }
9430
9431
9432 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9433 PyObject *resultobj;
9434 wxChar *result;
9435 char *kwnames[] = {
9436 NULL
9437 };
9438
9439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9440 {
9441 PyThreadState* __tstate = wxPyBeginAllowThreads();
9442 result = (wxChar *)wxLog::GetTimestamp();
9443
9444 wxPyEndAllowThreads(__tstate);
9445 if (PyErr_Occurred()) SWIG_fail;
9446 }
9447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9448 return resultobj;
9449 fail:
9450 return NULL;
9451 }
9452
9453
9454 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9455 PyObject *resultobj;
9456 wxString result;
9457 char *kwnames[] = {
9458 NULL
9459 };
9460
9461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9462 {
9463 PyThreadState* __tstate = wxPyBeginAllowThreads();
9464 result = Log_TimeStamp();
9465
9466 wxPyEndAllowThreads(__tstate);
9467 if (PyErr_Occurred()) SWIG_fail;
9468 }
9469 {
9470 #if wxUSE_UNICODE
9471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9472 #else
9473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9474 #endif
9475 }
9476 return resultobj;
9477 fail:
9478 return NULL;
9479 }
9480
9481
9482 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9483 PyObject *resultobj;
9484 wxLog *arg1 = (wxLog *) 0 ;
9485 PyObject * obj0 = 0 ;
9486 char *kwnames[] = {
9487 (char *) "self", NULL
9488 };
9489
9490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9492 if (SWIG_arg_fail(1)) SWIG_fail;
9493 {
9494 PyThreadState* __tstate = wxPyBeginAllowThreads();
9495 wxLog_Destroy(arg1);
9496
9497 wxPyEndAllowThreads(__tstate);
9498 if (PyErr_Occurred()) SWIG_fail;
9499 }
9500 Py_INCREF(Py_None); resultobj = Py_None;
9501 return resultobj;
9502 fail:
9503 return NULL;
9504 }
9505
9506
9507 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9508 PyObject *obj;
9509 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9510 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9511 Py_INCREF(obj);
9512 return Py_BuildValue((char *)"");
9513 }
9514 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9515 PyObject *resultobj;
9516 wxLogStderr *result;
9517 char *kwnames[] = {
9518 NULL
9519 };
9520
9521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9522 {
9523 PyThreadState* __tstate = wxPyBeginAllowThreads();
9524 result = (wxLogStderr *)new wxLogStderr();
9525
9526 wxPyEndAllowThreads(__tstate);
9527 if (PyErr_Occurred()) SWIG_fail;
9528 }
9529 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9530 return resultobj;
9531 fail:
9532 return NULL;
9533 }
9534
9535
9536 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9537 PyObject *obj;
9538 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9539 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9540 Py_INCREF(obj);
9541 return Py_BuildValue((char *)"");
9542 }
9543 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9544 PyObject *resultobj;
9545 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9546 wxLogTextCtrl *result;
9547 PyObject * obj0 = 0 ;
9548 char *kwnames[] = {
9549 (char *) "pTextCtrl", NULL
9550 };
9551
9552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9554 if (SWIG_arg_fail(1)) SWIG_fail;
9555 {
9556 PyThreadState* __tstate = wxPyBeginAllowThreads();
9557 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9558
9559 wxPyEndAllowThreads(__tstate);
9560 if (PyErr_Occurred()) SWIG_fail;
9561 }
9562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9563 return resultobj;
9564 fail:
9565 return NULL;
9566 }
9567
9568
9569 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9570 PyObject *obj;
9571 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9572 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9573 Py_INCREF(obj);
9574 return Py_BuildValue((char *)"");
9575 }
9576 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9577 PyObject *resultobj;
9578 wxLogGui *result;
9579 char *kwnames[] = {
9580 NULL
9581 };
9582
9583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9584 {
9585 PyThreadState* __tstate = wxPyBeginAllowThreads();
9586 result = (wxLogGui *)new wxLogGui();
9587
9588 wxPyEndAllowThreads(__tstate);
9589 if (PyErr_Occurred()) SWIG_fail;
9590 }
9591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9592 return resultobj;
9593 fail:
9594 return NULL;
9595 }
9596
9597
9598 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9599 PyObject *obj;
9600 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9601 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9602 Py_INCREF(obj);
9603 return Py_BuildValue((char *)"");
9604 }
9605 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9606 PyObject *resultobj;
9607 wxFrame *arg1 = (wxFrame *) 0 ;
9608 wxString *arg2 = 0 ;
9609 bool arg3 = (bool) true ;
9610 bool arg4 = (bool) true ;
9611 wxLogWindow *result;
9612 bool temp2 = false ;
9613 PyObject * obj0 = 0 ;
9614 PyObject * obj1 = 0 ;
9615 PyObject * obj2 = 0 ;
9616 PyObject * obj3 = 0 ;
9617 char *kwnames[] = {
9618 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9619 };
9620
9621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9623 if (SWIG_arg_fail(1)) SWIG_fail;
9624 {
9625 arg2 = wxString_in_helper(obj1);
9626 if (arg2 == NULL) SWIG_fail;
9627 temp2 = true;
9628 }
9629 if (obj2) {
9630 {
9631 arg3 = (bool)(SWIG_As_bool(obj2));
9632 if (SWIG_arg_fail(3)) SWIG_fail;
9633 }
9634 }
9635 if (obj3) {
9636 {
9637 arg4 = (bool)(SWIG_As_bool(obj3));
9638 if (SWIG_arg_fail(4)) SWIG_fail;
9639 }
9640 }
9641 {
9642 PyThreadState* __tstate = wxPyBeginAllowThreads();
9643 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9644
9645 wxPyEndAllowThreads(__tstate);
9646 if (PyErr_Occurred()) SWIG_fail;
9647 }
9648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9649 {
9650 if (temp2)
9651 delete arg2;
9652 }
9653 return resultobj;
9654 fail:
9655 {
9656 if (temp2)
9657 delete arg2;
9658 }
9659 return NULL;
9660 }
9661
9662
9663 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9664 PyObject *resultobj;
9665 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9666 bool arg2 = (bool) true ;
9667 PyObject * obj0 = 0 ;
9668 PyObject * obj1 = 0 ;
9669 char *kwnames[] = {
9670 (char *) "self",(char *) "bShow", NULL
9671 };
9672
9673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9675 if (SWIG_arg_fail(1)) SWIG_fail;
9676 if (obj1) {
9677 {
9678 arg2 = (bool)(SWIG_As_bool(obj1));
9679 if (SWIG_arg_fail(2)) SWIG_fail;
9680 }
9681 }
9682 {
9683 PyThreadState* __tstate = wxPyBeginAllowThreads();
9684 (arg1)->Show(arg2);
9685
9686 wxPyEndAllowThreads(__tstate);
9687 if (PyErr_Occurred()) SWIG_fail;
9688 }
9689 Py_INCREF(Py_None); resultobj = Py_None;
9690 return resultobj;
9691 fail:
9692 return NULL;
9693 }
9694
9695
9696 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9697 PyObject *resultobj;
9698 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9699 wxFrame *result;
9700 PyObject * obj0 = 0 ;
9701 char *kwnames[] = {
9702 (char *) "self", NULL
9703 };
9704
9705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9707 if (SWIG_arg_fail(1)) SWIG_fail;
9708 {
9709 PyThreadState* __tstate = wxPyBeginAllowThreads();
9710 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9711
9712 wxPyEndAllowThreads(__tstate);
9713 if (PyErr_Occurred()) SWIG_fail;
9714 }
9715 {
9716 resultobj = wxPyMake_wxObject(result, 0);
9717 }
9718 return resultobj;
9719 fail:
9720 return NULL;
9721 }
9722
9723
9724 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9725 PyObject *resultobj;
9726 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9727 wxLog *result;
9728 PyObject * obj0 = 0 ;
9729 char *kwnames[] = {
9730 (char *) "self", NULL
9731 };
9732
9733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9735 if (SWIG_arg_fail(1)) SWIG_fail;
9736 {
9737 PyThreadState* __tstate = wxPyBeginAllowThreads();
9738 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9739
9740 wxPyEndAllowThreads(__tstate);
9741 if (PyErr_Occurred()) SWIG_fail;
9742 }
9743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9744 return resultobj;
9745 fail:
9746 return NULL;
9747 }
9748
9749
9750 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9751 PyObject *resultobj;
9752 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9753 bool result;
9754 PyObject * obj0 = 0 ;
9755 char *kwnames[] = {
9756 (char *) "self", NULL
9757 };
9758
9759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9761 if (SWIG_arg_fail(1)) SWIG_fail;
9762 {
9763 PyThreadState* __tstate = wxPyBeginAllowThreads();
9764 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9765
9766 wxPyEndAllowThreads(__tstate);
9767 if (PyErr_Occurred()) SWIG_fail;
9768 }
9769 {
9770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9771 }
9772 return resultobj;
9773 fail:
9774 return NULL;
9775 }
9776
9777
9778 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9779 PyObject *resultobj;
9780 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9781 bool arg2 ;
9782 PyObject * obj0 = 0 ;
9783 PyObject * obj1 = 0 ;
9784 char *kwnames[] = {
9785 (char *) "self",(char *) "bDoPass", NULL
9786 };
9787
9788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) 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 arg2 = (bool)(SWIG_As_bool(obj1));
9793 if (SWIG_arg_fail(2)) SWIG_fail;
9794 }
9795 {
9796 PyThreadState* __tstate = wxPyBeginAllowThreads();
9797 (arg1)->PassMessages(arg2);
9798
9799 wxPyEndAllowThreads(__tstate);
9800 if (PyErr_Occurred()) SWIG_fail;
9801 }
9802 Py_INCREF(Py_None); resultobj = Py_None;
9803 return resultobj;
9804 fail:
9805 return NULL;
9806 }
9807
9808
9809 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9810 PyObject *obj;
9811 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9812 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9813 Py_INCREF(obj);
9814 return Py_BuildValue((char *)"");
9815 }
9816 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9817 PyObject *resultobj;
9818 wxLog *arg1 = (wxLog *) 0 ;
9819 wxLogChain *result;
9820 PyObject * obj0 = 0 ;
9821 char *kwnames[] = {
9822 (char *) "logger", NULL
9823 };
9824
9825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9827 if (SWIG_arg_fail(1)) SWIG_fail;
9828 {
9829 PyThreadState* __tstate = wxPyBeginAllowThreads();
9830 result = (wxLogChain *)new wxLogChain(arg1);
9831
9832 wxPyEndAllowThreads(__tstate);
9833 if (PyErr_Occurred()) SWIG_fail;
9834 }
9835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9836 return resultobj;
9837 fail:
9838 return NULL;
9839 }
9840
9841
9842 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9843 PyObject *resultobj;
9844 wxLogChain *arg1 = (wxLogChain *) 0 ;
9845 wxLog *arg2 = (wxLog *) 0 ;
9846 PyObject * obj0 = 0 ;
9847 PyObject * obj1 = 0 ;
9848 char *kwnames[] = {
9849 (char *) "self",(char *) "logger", NULL
9850 };
9851
9852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9854 if (SWIG_arg_fail(1)) SWIG_fail;
9855 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9856 if (SWIG_arg_fail(2)) SWIG_fail;
9857 {
9858 PyThreadState* __tstate = wxPyBeginAllowThreads();
9859 (arg1)->SetLog(arg2);
9860
9861 wxPyEndAllowThreads(__tstate);
9862 if (PyErr_Occurred()) SWIG_fail;
9863 }
9864 Py_INCREF(Py_None); resultobj = Py_None;
9865 return resultobj;
9866 fail:
9867 return NULL;
9868 }
9869
9870
9871 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9872 PyObject *resultobj;
9873 wxLogChain *arg1 = (wxLogChain *) 0 ;
9874 bool arg2 ;
9875 PyObject * obj0 = 0 ;
9876 PyObject * obj1 = 0 ;
9877 char *kwnames[] = {
9878 (char *) "self",(char *) "bDoPass", NULL
9879 };
9880
9881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9883 if (SWIG_arg_fail(1)) SWIG_fail;
9884 {
9885 arg2 = (bool)(SWIG_As_bool(obj1));
9886 if (SWIG_arg_fail(2)) SWIG_fail;
9887 }
9888 {
9889 PyThreadState* __tstate = wxPyBeginAllowThreads();
9890 (arg1)->PassMessages(arg2);
9891
9892 wxPyEndAllowThreads(__tstate);
9893 if (PyErr_Occurred()) SWIG_fail;
9894 }
9895 Py_INCREF(Py_None); resultobj = Py_None;
9896 return resultobj;
9897 fail:
9898 return NULL;
9899 }
9900
9901
9902 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9903 PyObject *resultobj;
9904 wxLogChain *arg1 = (wxLogChain *) 0 ;
9905 bool result;
9906 PyObject * obj0 = 0 ;
9907 char *kwnames[] = {
9908 (char *) "self", NULL
9909 };
9910
9911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9913 if (SWIG_arg_fail(1)) SWIG_fail;
9914 {
9915 PyThreadState* __tstate = wxPyBeginAllowThreads();
9916 result = (bool)(arg1)->IsPassingMessages();
9917
9918 wxPyEndAllowThreads(__tstate);
9919 if (PyErr_Occurred()) SWIG_fail;
9920 }
9921 {
9922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9923 }
9924 return resultobj;
9925 fail:
9926 return NULL;
9927 }
9928
9929
9930 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9931 PyObject *resultobj;
9932 wxLogChain *arg1 = (wxLogChain *) 0 ;
9933 wxLog *result;
9934 PyObject * obj0 = 0 ;
9935 char *kwnames[] = {
9936 (char *) "self", NULL
9937 };
9938
9939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9941 if (SWIG_arg_fail(1)) SWIG_fail;
9942 {
9943 PyThreadState* __tstate = wxPyBeginAllowThreads();
9944 result = (wxLog *)(arg1)->GetOldLog();
9945
9946 wxPyEndAllowThreads(__tstate);
9947 if (PyErr_Occurred()) SWIG_fail;
9948 }
9949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9950 return resultobj;
9951 fail:
9952 return NULL;
9953 }
9954
9955
9956 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9957 PyObject *obj;
9958 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9959 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9960 Py_INCREF(obj);
9961 return Py_BuildValue((char *)"");
9962 }
9963 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9964 PyObject *resultobj;
9965 unsigned long result;
9966 char *kwnames[] = {
9967 NULL
9968 };
9969
9970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9971 {
9972 PyThreadState* __tstate = wxPyBeginAllowThreads();
9973 result = (unsigned long)wxSysErrorCode();
9974
9975 wxPyEndAllowThreads(__tstate);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 {
9979 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9980 }
9981 return resultobj;
9982 fail:
9983 return NULL;
9984 }
9985
9986
9987 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9988 PyObject *resultobj;
9989 unsigned long arg1 = (unsigned long) 0 ;
9990 wxString result;
9991 PyObject * obj0 = 0 ;
9992 char *kwnames[] = {
9993 (char *) "nErrCode", NULL
9994 };
9995
9996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9997 if (obj0) {
9998 {
9999 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10000 if (SWIG_arg_fail(1)) SWIG_fail;
10001 }
10002 }
10003 {
10004 PyThreadState* __tstate = wxPyBeginAllowThreads();
10005 result = wxSysErrorMsg(arg1);
10006
10007 wxPyEndAllowThreads(__tstate);
10008 if (PyErr_Occurred()) SWIG_fail;
10009 }
10010 {
10011 #if wxUSE_UNICODE
10012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10013 #else
10014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10015 #endif
10016 }
10017 return resultobj;
10018 fail:
10019 return NULL;
10020 }
10021
10022
10023 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10024 PyObject *resultobj;
10025 wxString *arg1 = 0 ;
10026 bool temp1 = false ;
10027 PyObject * obj0 = 0 ;
10028 char *kwnames[] = {
10029 (char *) "msg", NULL
10030 };
10031
10032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10033 {
10034 arg1 = wxString_in_helper(obj0);
10035 if (arg1 == NULL) SWIG_fail;
10036 temp1 = true;
10037 }
10038 {
10039 PyThreadState* __tstate = wxPyBeginAllowThreads();
10040 wxPyLogFatalError((wxString const &)*arg1);
10041
10042 wxPyEndAllowThreads(__tstate);
10043 if (PyErr_Occurred()) SWIG_fail;
10044 }
10045 Py_INCREF(Py_None); resultobj = Py_None;
10046 {
10047 if (temp1)
10048 delete arg1;
10049 }
10050 return resultobj;
10051 fail:
10052 {
10053 if (temp1)
10054 delete arg1;
10055 }
10056 return NULL;
10057 }
10058
10059
10060 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10061 PyObject *resultobj;
10062 wxString *arg1 = 0 ;
10063 bool temp1 = false ;
10064 PyObject * obj0 = 0 ;
10065 char *kwnames[] = {
10066 (char *) "msg", NULL
10067 };
10068
10069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10070 {
10071 arg1 = wxString_in_helper(obj0);
10072 if (arg1 == NULL) SWIG_fail;
10073 temp1 = true;
10074 }
10075 {
10076 PyThreadState* __tstate = wxPyBeginAllowThreads();
10077 wxPyLogError((wxString const &)*arg1);
10078
10079 wxPyEndAllowThreads(__tstate);
10080 if (PyErr_Occurred()) SWIG_fail;
10081 }
10082 Py_INCREF(Py_None); resultobj = Py_None;
10083 {
10084 if (temp1)
10085 delete arg1;
10086 }
10087 return resultobj;
10088 fail:
10089 {
10090 if (temp1)
10091 delete arg1;
10092 }
10093 return NULL;
10094 }
10095
10096
10097 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10098 PyObject *resultobj;
10099 wxString *arg1 = 0 ;
10100 bool temp1 = false ;
10101 PyObject * obj0 = 0 ;
10102 char *kwnames[] = {
10103 (char *) "msg", NULL
10104 };
10105
10106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10107 {
10108 arg1 = wxString_in_helper(obj0);
10109 if (arg1 == NULL) SWIG_fail;
10110 temp1 = true;
10111 }
10112 {
10113 PyThreadState* __tstate = wxPyBeginAllowThreads();
10114 wxPyLogWarning((wxString const &)*arg1);
10115
10116 wxPyEndAllowThreads(__tstate);
10117 if (PyErr_Occurred()) SWIG_fail;
10118 }
10119 Py_INCREF(Py_None); resultobj = Py_None;
10120 {
10121 if (temp1)
10122 delete arg1;
10123 }
10124 return resultobj;
10125 fail:
10126 {
10127 if (temp1)
10128 delete arg1;
10129 }
10130 return NULL;
10131 }
10132
10133
10134 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10135 PyObject *resultobj;
10136 wxString *arg1 = 0 ;
10137 bool temp1 = false ;
10138 PyObject * obj0 = 0 ;
10139 char *kwnames[] = {
10140 (char *) "msg", NULL
10141 };
10142
10143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10144 {
10145 arg1 = wxString_in_helper(obj0);
10146 if (arg1 == NULL) SWIG_fail;
10147 temp1 = true;
10148 }
10149 {
10150 PyThreadState* __tstate = wxPyBeginAllowThreads();
10151 wxPyLogMessage((wxString const &)*arg1);
10152
10153 wxPyEndAllowThreads(__tstate);
10154 if (PyErr_Occurred()) SWIG_fail;
10155 }
10156 Py_INCREF(Py_None); resultobj = Py_None;
10157 {
10158 if (temp1)
10159 delete arg1;
10160 }
10161 return resultobj;
10162 fail:
10163 {
10164 if (temp1)
10165 delete arg1;
10166 }
10167 return NULL;
10168 }
10169
10170
10171 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10172 PyObject *resultobj;
10173 wxString *arg1 = 0 ;
10174 bool temp1 = false ;
10175 PyObject * obj0 = 0 ;
10176 char *kwnames[] = {
10177 (char *) "msg", NULL
10178 };
10179
10180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10181 {
10182 arg1 = wxString_in_helper(obj0);
10183 if (arg1 == NULL) SWIG_fail;
10184 temp1 = true;
10185 }
10186 {
10187 PyThreadState* __tstate = wxPyBeginAllowThreads();
10188 wxPyLogInfo((wxString const &)*arg1);
10189
10190 wxPyEndAllowThreads(__tstate);
10191 if (PyErr_Occurred()) SWIG_fail;
10192 }
10193 Py_INCREF(Py_None); resultobj = Py_None;
10194 {
10195 if (temp1)
10196 delete arg1;
10197 }
10198 return resultobj;
10199 fail:
10200 {
10201 if (temp1)
10202 delete arg1;
10203 }
10204 return NULL;
10205 }
10206
10207
10208 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10209 PyObject *resultobj;
10210 wxString *arg1 = 0 ;
10211 bool temp1 = false ;
10212 PyObject * obj0 = 0 ;
10213 char *kwnames[] = {
10214 (char *) "msg", NULL
10215 };
10216
10217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10218 {
10219 arg1 = wxString_in_helper(obj0);
10220 if (arg1 == NULL) SWIG_fail;
10221 temp1 = true;
10222 }
10223 {
10224 PyThreadState* __tstate = wxPyBeginAllowThreads();
10225 wxPyLogDebug((wxString const &)*arg1);
10226
10227 wxPyEndAllowThreads(__tstate);
10228 if (PyErr_Occurred()) SWIG_fail;
10229 }
10230 Py_INCREF(Py_None); resultobj = Py_None;
10231 {
10232 if (temp1)
10233 delete arg1;
10234 }
10235 return resultobj;
10236 fail:
10237 {
10238 if (temp1)
10239 delete arg1;
10240 }
10241 return NULL;
10242 }
10243
10244
10245 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10246 PyObject *resultobj;
10247 wxString *arg1 = 0 ;
10248 bool temp1 = false ;
10249 PyObject * obj0 = 0 ;
10250 char *kwnames[] = {
10251 (char *) "msg", NULL
10252 };
10253
10254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10255 {
10256 arg1 = wxString_in_helper(obj0);
10257 if (arg1 == NULL) SWIG_fail;
10258 temp1 = true;
10259 }
10260 {
10261 PyThreadState* __tstate = wxPyBeginAllowThreads();
10262 wxPyLogVerbose((wxString const &)*arg1);
10263
10264 wxPyEndAllowThreads(__tstate);
10265 if (PyErr_Occurred()) SWIG_fail;
10266 }
10267 Py_INCREF(Py_None); resultobj = Py_None;
10268 {
10269 if (temp1)
10270 delete arg1;
10271 }
10272 return resultobj;
10273 fail:
10274 {
10275 if (temp1)
10276 delete arg1;
10277 }
10278 return NULL;
10279 }
10280
10281
10282 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10283 PyObject *resultobj;
10284 wxString *arg1 = 0 ;
10285 bool temp1 = false ;
10286 PyObject * obj0 = 0 ;
10287 char *kwnames[] = {
10288 (char *) "msg", NULL
10289 };
10290
10291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10292 {
10293 arg1 = wxString_in_helper(obj0);
10294 if (arg1 == NULL) SWIG_fail;
10295 temp1 = true;
10296 }
10297 {
10298 PyThreadState* __tstate = wxPyBeginAllowThreads();
10299 wxPyLogStatus((wxString const &)*arg1);
10300
10301 wxPyEndAllowThreads(__tstate);
10302 if (PyErr_Occurred()) SWIG_fail;
10303 }
10304 Py_INCREF(Py_None); resultobj = Py_None;
10305 {
10306 if (temp1)
10307 delete arg1;
10308 }
10309 return resultobj;
10310 fail:
10311 {
10312 if (temp1)
10313 delete arg1;
10314 }
10315 return NULL;
10316 }
10317
10318
10319 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10320 PyObject *resultobj;
10321 wxFrame *arg1 = (wxFrame *) 0 ;
10322 wxString *arg2 = 0 ;
10323 bool temp2 = false ;
10324 PyObject * obj0 = 0 ;
10325 PyObject * obj1 = 0 ;
10326 char *kwnames[] = {
10327 (char *) "pFrame",(char *) "msg", NULL
10328 };
10329
10330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10332 if (SWIG_arg_fail(1)) SWIG_fail;
10333 {
10334 arg2 = wxString_in_helper(obj1);
10335 if (arg2 == NULL) SWIG_fail;
10336 temp2 = true;
10337 }
10338 {
10339 PyThreadState* __tstate = wxPyBeginAllowThreads();
10340 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10341
10342 wxPyEndAllowThreads(__tstate);
10343 if (PyErr_Occurred()) SWIG_fail;
10344 }
10345 Py_INCREF(Py_None); resultobj = Py_None;
10346 {
10347 if (temp2)
10348 delete arg2;
10349 }
10350 return resultobj;
10351 fail:
10352 {
10353 if (temp2)
10354 delete arg2;
10355 }
10356 return NULL;
10357 }
10358
10359
10360 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10361 PyObject *resultobj;
10362 wxString *arg1 = 0 ;
10363 bool temp1 = false ;
10364 PyObject * obj0 = 0 ;
10365 char *kwnames[] = {
10366 (char *) "msg", NULL
10367 };
10368
10369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10370 {
10371 arg1 = wxString_in_helper(obj0);
10372 if (arg1 == NULL) SWIG_fail;
10373 temp1 = true;
10374 }
10375 {
10376 PyThreadState* __tstate = wxPyBeginAllowThreads();
10377 wxPyLogSysError((wxString const &)*arg1);
10378
10379 wxPyEndAllowThreads(__tstate);
10380 if (PyErr_Occurred()) SWIG_fail;
10381 }
10382 Py_INCREF(Py_None); resultobj = Py_None;
10383 {
10384 if (temp1)
10385 delete arg1;
10386 }
10387 return resultobj;
10388 fail:
10389 {
10390 if (temp1)
10391 delete arg1;
10392 }
10393 return NULL;
10394 }
10395
10396
10397 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10398 PyObject *resultobj;
10399 unsigned long arg1 ;
10400 wxString *arg2 = 0 ;
10401 bool temp2 = false ;
10402 PyObject * obj0 = 0 ;
10403 PyObject * obj1 = 0 ;
10404 char *kwnames[] = {
10405 (char *) "level",(char *) "msg", NULL
10406 };
10407
10408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10409 {
10410 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10411 if (SWIG_arg_fail(1)) SWIG_fail;
10412 }
10413 {
10414 arg2 = wxString_in_helper(obj1);
10415 if (arg2 == NULL) SWIG_fail;
10416 temp2 = true;
10417 }
10418 {
10419 PyThreadState* __tstate = wxPyBeginAllowThreads();
10420 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10421
10422 wxPyEndAllowThreads(__tstate);
10423 if (PyErr_Occurred()) SWIG_fail;
10424 }
10425 Py_INCREF(Py_None); resultobj = Py_None;
10426 {
10427 if (temp2)
10428 delete arg2;
10429 }
10430 return resultobj;
10431 fail:
10432 {
10433 if (temp2)
10434 delete arg2;
10435 }
10436 return NULL;
10437 }
10438
10439
10440 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10441 PyObject *resultobj;
10442 unsigned long arg1 ;
10443 wxString *arg2 = 0 ;
10444 bool temp2 = false ;
10445 PyObject * obj0 = 0 ;
10446 PyObject * obj1 = 0 ;
10447
10448 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10449 {
10450 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10451 if (SWIG_arg_fail(1)) SWIG_fail;
10452 }
10453 {
10454 arg2 = wxString_in_helper(obj1);
10455 if (arg2 == NULL) SWIG_fail;
10456 temp2 = true;
10457 }
10458 {
10459 PyThreadState* __tstate = wxPyBeginAllowThreads();
10460 wxPyLogTrace(arg1,(wxString const &)*arg2);
10461
10462 wxPyEndAllowThreads(__tstate);
10463 if (PyErr_Occurred()) SWIG_fail;
10464 }
10465 Py_INCREF(Py_None); resultobj = Py_None;
10466 {
10467 if (temp2)
10468 delete arg2;
10469 }
10470 return resultobj;
10471 fail:
10472 {
10473 if (temp2)
10474 delete arg2;
10475 }
10476 return NULL;
10477 }
10478
10479
10480 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10481 PyObject *resultobj;
10482 wxString *arg1 = 0 ;
10483 wxString *arg2 = 0 ;
10484 bool temp1 = false ;
10485 bool temp2 = false ;
10486 PyObject * obj0 = 0 ;
10487 PyObject * obj1 = 0 ;
10488
10489 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10490 {
10491 arg1 = wxString_in_helper(obj0);
10492 if (arg1 == NULL) SWIG_fail;
10493 temp1 = true;
10494 }
10495 {
10496 arg2 = wxString_in_helper(obj1);
10497 if (arg2 == NULL) SWIG_fail;
10498 temp2 = true;
10499 }
10500 {
10501 PyThreadState* __tstate = wxPyBeginAllowThreads();
10502 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10503
10504 wxPyEndAllowThreads(__tstate);
10505 if (PyErr_Occurred()) SWIG_fail;
10506 }
10507 Py_INCREF(Py_None); resultobj = Py_None;
10508 {
10509 if (temp1)
10510 delete arg1;
10511 }
10512 {
10513 if (temp2)
10514 delete arg2;
10515 }
10516 return resultobj;
10517 fail:
10518 {
10519 if (temp1)
10520 delete arg1;
10521 }
10522 {
10523 if (temp2)
10524 delete arg2;
10525 }
10526 return NULL;
10527 }
10528
10529
10530 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10531 int argc;
10532 PyObject *argv[3];
10533 int ii;
10534
10535 argc = PyObject_Length(args);
10536 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10537 argv[ii] = PyTuple_GetItem(args,ii);
10538 }
10539 if (argc == 2) {
10540 int _v;
10541 {
10542 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10543 }
10544 if (_v) {
10545 {
10546 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10547 }
10548 if (_v) {
10549 return _wrap_LogTrace__SWIG_1(self,args);
10550 }
10551 }
10552 }
10553 if (argc == 2) {
10554 int _v;
10555 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10556 if (_v) {
10557 {
10558 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10559 }
10560 if (_v) {
10561 return _wrap_LogTrace__SWIG_0(self,args);
10562 }
10563 }
10564 }
10565
10566 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10567 return NULL;
10568 }
10569
10570
10571 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10572 PyObject *resultobj;
10573 wxString *arg1 = 0 ;
10574 wxString *arg2 = 0 ;
10575 bool temp1 = false ;
10576 bool temp2 = false ;
10577 PyObject * obj0 = 0 ;
10578 PyObject * obj1 = 0 ;
10579 char *kwnames[] = {
10580 (char *) "title",(char *) "text", NULL
10581 };
10582
10583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10584 {
10585 arg1 = wxString_in_helper(obj0);
10586 if (arg1 == NULL) SWIG_fail;
10587 temp1 = true;
10588 }
10589 {
10590 arg2 = wxString_in_helper(obj1);
10591 if (arg2 == NULL) SWIG_fail;
10592 temp2 = true;
10593 }
10594 {
10595 PyThreadState* __tstate = wxPyBeginAllowThreads();
10596 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10597
10598 wxPyEndAllowThreads(__tstate);
10599 if (PyErr_Occurred()) SWIG_fail;
10600 }
10601 Py_INCREF(Py_None); resultobj = Py_None;
10602 {
10603 if (temp1)
10604 delete arg1;
10605 }
10606 {
10607 if (temp2)
10608 delete arg2;
10609 }
10610 return resultobj;
10611 fail:
10612 {
10613 if (temp1)
10614 delete arg1;
10615 }
10616 {
10617 if (temp2)
10618 delete arg2;
10619 }
10620 return NULL;
10621 }
10622
10623
10624 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10625 PyObject *resultobj;
10626 wxLogNull *result;
10627 char *kwnames[] = {
10628 NULL
10629 };
10630
10631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10632 {
10633 PyThreadState* __tstate = wxPyBeginAllowThreads();
10634 result = (wxLogNull *)new wxLogNull();
10635
10636 wxPyEndAllowThreads(__tstate);
10637 if (PyErr_Occurred()) SWIG_fail;
10638 }
10639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10640 return resultobj;
10641 fail:
10642 return NULL;
10643 }
10644
10645
10646 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10647 PyObject *resultobj;
10648 wxLogNull *arg1 = (wxLogNull *) 0 ;
10649 PyObject * obj0 = 0 ;
10650 char *kwnames[] = {
10651 (char *) "self", NULL
10652 };
10653
10654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10656 if (SWIG_arg_fail(1)) SWIG_fail;
10657 {
10658 PyThreadState* __tstate = wxPyBeginAllowThreads();
10659 delete arg1;
10660
10661 wxPyEndAllowThreads(__tstate);
10662 if (PyErr_Occurred()) SWIG_fail;
10663 }
10664 Py_INCREF(Py_None); resultobj = Py_None;
10665 return resultobj;
10666 fail:
10667 return NULL;
10668 }
10669
10670
10671 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10672 PyObject *obj;
10673 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10674 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10675 Py_INCREF(obj);
10676 return Py_BuildValue((char *)"");
10677 }
10678 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10679 PyObject *resultobj;
10680 wxPyLog *result;
10681 char *kwnames[] = {
10682 NULL
10683 };
10684
10685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10686 {
10687 PyThreadState* __tstate = wxPyBeginAllowThreads();
10688 result = (wxPyLog *)new wxPyLog();
10689
10690 wxPyEndAllowThreads(__tstate);
10691 if (PyErr_Occurred()) SWIG_fail;
10692 }
10693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10694 return resultobj;
10695 fail:
10696 return NULL;
10697 }
10698
10699
10700 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10701 PyObject *resultobj;
10702 wxPyLog *arg1 = (wxPyLog *) 0 ;
10703 PyObject *arg2 = (PyObject *) 0 ;
10704 PyObject *arg3 = (PyObject *) 0 ;
10705 PyObject * obj0 = 0 ;
10706 PyObject * obj1 = 0 ;
10707 PyObject * obj2 = 0 ;
10708 char *kwnames[] = {
10709 (char *) "self",(char *) "self",(char *) "_class", NULL
10710 };
10711
10712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10714 if (SWIG_arg_fail(1)) SWIG_fail;
10715 arg2 = obj1;
10716 arg3 = obj2;
10717 {
10718 PyThreadState* __tstate = wxPyBeginAllowThreads();
10719 (arg1)->_setCallbackInfo(arg2,arg3);
10720
10721 wxPyEndAllowThreads(__tstate);
10722 if (PyErr_Occurred()) SWIG_fail;
10723 }
10724 Py_INCREF(Py_None); resultobj = Py_None;
10725 return resultobj;
10726 fail:
10727 return NULL;
10728 }
10729
10730
10731 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10732 PyObject *obj;
10733 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10734 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10735 Py_INCREF(obj);
10736 return Py_BuildValue((char *)"");
10737 }
10738 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10739 PyObject *resultobj;
10740 int arg1 ;
10741 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10742 int arg3 = (int) wxKILL_NOCHILDREN ;
10743 wxKillError result;
10744 PyObject * obj0 = 0 ;
10745 PyObject * obj1 = 0 ;
10746 PyObject * obj2 = 0 ;
10747 char *kwnames[] = {
10748 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10749 };
10750
10751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10752 {
10753 arg1 = (int)(SWIG_As_int(obj0));
10754 if (SWIG_arg_fail(1)) SWIG_fail;
10755 }
10756 if (obj1) {
10757 {
10758 arg2 = (wxSignal)(SWIG_As_int(obj1));
10759 if (SWIG_arg_fail(2)) SWIG_fail;
10760 }
10761 }
10762 if (obj2) {
10763 {
10764 arg3 = (int)(SWIG_As_int(obj2));
10765 if (SWIG_arg_fail(3)) SWIG_fail;
10766 }
10767 }
10768 {
10769 PyThreadState* __tstate = wxPyBeginAllowThreads();
10770 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10771
10772 wxPyEndAllowThreads(__tstate);
10773 if (PyErr_Occurred()) SWIG_fail;
10774 }
10775 resultobj = SWIG_From_int((result));
10776 return resultobj;
10777 fail:
10778 return NULL;
10779 }
10780
10781
10782 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10783 PyObject *resultobj;
10784 int arg1 ;
10785 bool result;
10786 PyObject * obj0 = 0 ;
10787 char *kwnames[] = {
10788 (char *) "pid", NULL
10789 };
10790
10791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10792 {
10793 arg1 = (int)(SWIG_As_int(obj0));
10794 if (SWIG_arg_fail(1)) SWIG_fail;
10795 }
10796 {
10797 PyThreadState* __tstate = wxPyBeginAllowThreads();
10798 result = (bool)wxPyProcess::Exists(arg1);
10799
10800 wxPyEndAllowThreads(__tstate);
10801 if (PyErr_Occurred()) SWIG_fail;
10802 }
10803 {
10804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10805 }
10806 return resultobj;
10807 fail:
10808 return NULL;
10809 }
10810
10811
10812 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10813 PyObject *resultobj;
10814 wxString *arg1 = 0 ;
10815 int arg2 = (int) wxEXEC_ASYNC ;
10816 wxPyProcess *result;
10817 bool temp1 = false ;
10818 PyObject * obj0 = 0 ;
10819 PyObject * obj1 = 0 ;
10820 char *kwnames[] = {
10821 (char *) "cmd",(char *) "flags", NULL
10822 };
10823
10824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10825 {
10826 arg1 = wxString_in_helper(obj0);
10827 if (arg1 == NULL) SWIG_fail;
10828 temp1 = true;
10829 }
10830 if (obj1) {
10831 {
10832 arg2 = (int)(SWIG_As_int(obj1));
10833 if (SWIG_arg_fail(2)) SWIG_fail;
10834 }
10835 }
10836 {
10837 PyThreadState* __tstate = wxPyBeginAllowThreads();
10838 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10839
10840 wxPyEndAllowThreads(__tstate);
10841 if (PyErr_Occurred()) SWIG_fail;
10842 }
10843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10844 {
10845 if (temp1)
10846 delete arg1;
10847 }
10848 return resultobj;
10849 fail:
10850 {
10851 if (temp1)
10852 delete arg1;
10853 }
10854 return NULL;
10855 }
10856
10857
10858 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10859 PyObject *resultobj;
10860 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10861 int arg2 = (int) -1 ;
10862 wxPyProcess *result;
10863 PyObject * obj0 = 0 ;
10864 PyObject * obj1 = 0 ;
10865 char *kwnames[] = {
10866 (char *) "parent",(char *) "id", NULL
10867 };
10868
10869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10870 if (obj0) {
10871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10872 if (SWIG_arg_fail(1)) SWIG_fail;
10873 }
10874 if (obj1) {
10875 {
10876 arg2 = (int)(SWIG_As_int(obj1));
10877 if (SWIG_arg_fail(2)) SWIG_fail;
10878 }
10879 }
10880 {
10881 PyThreadState* __tstate = wxPyBeginAllowThreads();
10882 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10883
10884 wxPyEndAllowThreads(__tstate);
10885 if (PyErr_Occurred()) SWIG_fail;
10886 }
10887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10888 return resultobj;
10889 fail:
10890 return NULL;
10891 }
10892
10893
10894 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10895 PyObject *resultobj;
10896 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10897 PyObject *arg2 = (PyObject *) 0 ;
10898 PyObject *arg3 = (PyObject *) 0 ;
10899 PyObject * obj0 = 0 ;
10900 PyObject * obj1 = 0 ;
10901 PyObject * obj2 = 0 ;
10902 char *kwnames[] = {
10903 (char *) "self",(char *) "self",(char *) "_class", NULL
10904 };
10905
10906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10908 if (SWIG_arg_fail(1)) SWIG_fail;
10909 arg2 = obj1;
10910 arg3 = obj2;
10911 {
10912 PyThreadState* __tstate = wxPyBeginAllowThreads();
10913 (arg1)->_setCallbackInfo(arg2,arg3);
10914
10915 wxPyEndAllowThreads(__tstate);
10916 if (PyErr_Occurred()) SWIG_fail;
10917 }
10918 Py_INCREF(Py_None); resultobj = Py_None;
10919 return resultobj;
10920 fail:
10921 return NULL;
10922 }
10923
10924
10925 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10926 PyObject *resultobj;
10927 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10928 int arg2 ;
10929 int arg3 ;
10930 PyObject * obj0 = 0 ;
10931 PyObject * obj1 = 0 ;
10932 PyObject * obj2 = 0 ;
10933 char *kwnames[] = {
10934 (char *) "self",(char *) "pid",(char *) "status", NULL
10935 };
10936
10937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10939 if (SWIG_arg_fail(1)) SWIG_fail;
10940 {
10941 arg2 = (int)(SWIG_As_int(obj1));
10942 if (SWIG_arg_fail(2)) SWIG_fail;
10943 }
10944 {
10945 arg3 = (int)(SWIG_As_int(obj2));
10946 if (SWIG_arg_fail(3)) SWIG_fail;
10947 }
10948 {
10949 PyThreadState* __tstate = wxPyBeginAllowThreads();
10950 (arg1)->base_OnTerminate(arg2,arg3);
10951
10952 wxPyEndAllowThreads(__tstate);
10953 if (PyErr_Occurred()) SWIG_fail;
10954 }
10955 Py_INCREF(Py_None); resultobj = Py_None;
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10963 PyObject *resultobj;
10964 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10965 PyObject * obj0 = 0 ;
10966 char *kwnames[] = {
10967 (char *) "self", NULL
10968 };
10969
10970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10972 if (SWIG_arg_fail(1)) SWIG_fail;
10973 {
10974 PyThreadState* __tstate = wxPyBeginAllowThreads();
10975 (arg1)->Redirect();
10976
10977 wxPyEndAllowThreads(__tstate);
10978 if (PyErr_Occurred()) SWIG_fail;
10979 }
10980 Py_INCREF(Py_None); resultobj = Py_None;
10981 return resultobj;
10982 fail:
10983 return NULL;
10984 }
10985
10986
10987 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10988 PyObject *resultobj;
10989 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10990 bool result;
10991 PyObject * obj0 = 0 ;
10992 char *kwnames[] = {
10993 (char *) "self", NULL
10994 };
10995
10996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10998 if (SWIG_arg_fail(1)) SWIG_fail;
10999 {
11000 PyThreadState* __tstate = wxPyBeginAllowThreads();
11001 result = (bool)(arg1)->IsRedirected();
11002
11003 wxPyEndAllowThreads(__tstate);
11004 if (PyErr_Occurred()) SWIG_fail;
11005 }
11006 {
11007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11008 }
11009 return resultobj;
11010 fail:
11011 return NULL;
11012 }
11013
11014
11015 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11016 PyObject *resultobj;
11017 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11018 PyObject * obj0 = 0 ;
11019 char *kwnames[] = {
11020 (char *) "self", NULL
11021 };
11022
11023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11025 if (SWIG_arg_fail(1)) SWIG_fail;
11026 {
11027 PyThreadState* __tstate = wxPyBeginAllowThreads();
11028 (arg1)->Detach();
11029
11030 wxPyEndAllowThreads(__tstate);
11031 if (PyErr_Occurred()) SWIG_fail;
11032 }
11033 Py_INCREF(Py_None); resultobj = Py_None;
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11041 PyObject *resultobj;
11042 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11043 wxInputStream *result;
11044 PyObject * obj0 = 0 ;
11045 char *kwnames[] = {
11046 (char *) "self", NULL
11047 };
11048
11049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11051 if (SWIG_arg_fail(1)) SWIG_fail;
11052 {
11053 PyThreadState* __tstate = wxPyBeginAllowThreads();
11054 result = (wxInputStream *)(arg1)->GetInputStream();
11055
11056 wxPyEndAllowThreads(__tstate);
11057 if (PyErr_Occurred()) SWIG_fail;
11058 }
11059 {
11060 wxPyInputStream * _ptr = NULL;
11061
11062 if (result) {
11063 _ptr = new wxPyInputStream(result);
11064 }
11065 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11066 }
11067 return resultobj;
11068 fail:
11069 return NULL;
11070 }
11071
11072
11073 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11074 PyObject *resultobj;
11075 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11076 wxInputStream *result;
11077 PyObject * obj0 = 0 ;
11078 char *kwnames[] = {
11079 (char *) "self", NULL
11080 };
11081
11082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11084 if (SWIG_arg_fail(1)) SWIG_fail;
11085 {
11086 PyThreadState* __tstate = wxPyBeginAllowThreads();
11087 result = (wxInputStream *)(arg1)->GetErrorStream();
11088
11089 wxPyEndAllowThreads(__tstate);
11090 if (PyErr_Occurred()) SWIG_fail;
11091 }
11092 {
11093 wxPyInputStream * _ptr = NULL;
11094
11095 if (result) {
11096 _ptr = new wxPyInputStream(result);
11097 }
11098 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11099 }
11100 return resultobj;
11101 fail:
11102 return NULL;
11103 }
11104
11105
11106 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11107 PyObject *resultobj;
11108 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11109 wxOutputStream *result;
11110 PyObject * obj0 = 0 ;
11111 char *kwnames[] = {
11112 (char *) "self", NULL
11113 };
11114
11115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11117 if (SWIG_arg_fail(1)) SWIG_fail;
11118 {
11119 PyThreadState* __tstate = wxPyBeginAllowThreads();
11120 result = (wxOutputStream *)(arg1)->GetOutputStream();
11121
11122 wxPyEndAllowThreads(__tstate);
11123 if (PyErr_Occurred()) SWIG_fail;
11124 }
11125 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11126 return resultobj;
11127 fail:
11128 return NULL;
11129 }
11130
11131
11132 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11133 PyObject *resultobj;
11134 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11135 PyObject * obj0 = 0 ;
11136 char *kwnames[] = {
11137 (char *) "self", NULL
11138 };
11139
11140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11142 if (SWIG_arg_fail(1)) SWIG_fail;
11143 {
11144 PyThreadState* __tstate = wxPyBeginAllowThreads();
11145 (arg1)->CloseOutput();
11146
11147 wxPyEndAllowThreads(__tstate);
11148 if (PyErr_Occurred()) SWIG_fail;
11149 }
11150 Py_INCREF(Py_None); resultobj = Py_None;
11151 return resultobj;
11152 fail:
11153 return NULL;
11154 }
11155
11156
11157 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11158 PyObject *resultobj;
11159 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11160 bool result;
11161 PyObject * obj0 = 0 ;
11162 char *kwnames[] = {
11163 (char *) "self", NULL
11164 };
11165
11166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11168 if (SWIG_arg_fail(1)) SWIG_fail;
11169 {
11170 PyThreadState* __tstate = wxPyBeginAllowThreads();
11171 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11172
11173 wxPyEndAllowThreads(__tstate);
11174 if (PyErr_Occurred()) SWIG_fail;
11175 }
11176 {
11177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11178 }
11179 return resultobj;
11180 fail:
11181 return NULL;
11182 }
11183
11184
11185 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11186 PyObject *resultobj;
11187 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11188 bool result;
11189 PyObject * obj0 = 0 ;
11190 char *kwnames[] = {
11191 (char *) "self", NULL
11192 };
11193
11194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11196 if (SWIG_arg_fail(1)) SWIG_fail;
11197 {
11198 PyThreadState* __tstate = wxPyBeginAllowThreads();
11199 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11200
11201 wxPyEndAllowThreads(__tstate);
11202 if (PyErr_Occurred()) SWIG_fail;
11203 }
11204 {
11205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11206 }
11207 return resultobj;
11208 fail:
11209 return NULL;
11210 }
11211
11212
11213 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11214 PyObject *resultobj;
11215 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11216 bool result;
11217 PyObject * obj0 = 0 ;
11218 char *kwnames[] = {
11219 (char *) "self", NULL
11220 };
11221
11222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11224 if (SWIG_arg_fail(1)) SWIG_fail;
11225 {
11226 PyThreadState* __tstate = wxPyBeginAllowThreads();
11227 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11228
11229 wxPyEndAllowThreads(__tstate);
11230 if (PyErr_Occurred()) SWIG_fail;
11231 }
11232 {
11233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11234 }
11235 return resultobj;
11236 fail:
11237 return NULL;
11238 }
11239
11240
11241 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11242 PyObject *obj;
11243 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11244 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11245 Py_INCREF(obj);
11246 return Py_BuildValue((char *)"");
11247 }
11248 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11249 PyObject *resultobj;
11250 int arg1 = (int) 0 ;
11251 int arg2 = (int) 0 ;
11252 int arg3 = (int) 0 ;
11253 wxProcessEvent *result;
11254 PyObject * obj0 = 0 ;
11255 PyObject * obj1 = 0 ;
11256 PyObject * obj2 = 0 ;
11257 char *kwnames[] = {
11258 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11259 };
11260
11261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11262 if (obj0) {
11263 {
11264 arg1 = (int)(SWIG_As_int(obj0));
11265 if (SWIG_arg_fail(1)) SWIG_fail;
11266 }
11267 }
11268 if (obj1) {
11269 {
11270 arg2 = (int)(SWIG_As_int(obj1));
11271 if (SWIG_arg_fail(2)) SWIG_fail;
11272 }
11273 }
11274 if (obj2) {
11275 {
11276 arg3 = (int)(SWIG_As_int(obj2));
11277 if (SWIG_arg_fail(3)) SWIG_fail;
11278 }
11279 }
11280 {
11281 PyThreadState* __tstate = wxPyBeginAllowThreads();
11282 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11283
11284 wxPyEndAllowThreads(__tstate);
11285 if (PyErr_Occurred()) SWIG_fail;
11286 }
11287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11288 return resultobj;
11289 fail:
11290 return NULL;
11291 }
11292
11293
11294 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11295 PyObject *resultobj;
11296 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11297 int result;
11298 PyObject * obj0 = 0 ;
11299 char *kwnames[] = {
11300 (char *) "self", NULL
11301 };
11302
11303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11305 if (SWIG_arg_fail(1)) SWIG_fail;
11306 {
11307 PyThreadState* __tstate = wxPyBeginAllowThreads();
11308 result = (int)(arg1)->GetPid();
11309
11310 wxPyEndAllowThreads(__tstate);
11311 if (PyErr_Occurred()) SWIG_fail;
11312 }
11313 {
11314 resultobj = SWIG_From_int((int)(result));
11315 }
11316 return resultobj;
11317 fail:
11318 return NULL;
11319 }
11320
11321
11322 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11323 PyObject *resultobj;
11324 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11325 int result;
11326 PyObject * obj0 = 0 ;
11327 char *kwnames[] = {
11328 (char *) "self", NULL
11329 };
11330
11331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11333 if (SWIG_arg_fail(1)) SWIG_fail;
11334 {
11335 PyThreadState* __tstate = wxPyBeginAllowThreads();
11336 result = (int)(arg1)->GetExitCode();
11337
11338 wxPyEndAllowThreads(__tstate);
11339 if (PyErr_Occurred()) SWIG_fail;
11340 }
11341 {
11342 resultobj = SWIG_From_int((int)(result));
11343 }
11344 return resultobj;
11345 fail:
11346 return NULL;
11347 }
11348
11349
11350 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11351 PyObject *resultobj;
11352 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11353 int arg2 ;
11354 PyObject * obj0 = 0 ;
11355 PyObject * obj1 = 0 ;
11356 char *kwnames[] = {
11357 (char *) "self",(char *) "m_pid", NULL
11358 };
11359
11360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11362 if (SWIG_arg_fail(1)) SWIG_fail;
11363 {
11364 arg2 = (int)(SWIG_As_int(obj1));
11365 if (SWIG_arg_fail(2)) SWIG_fail;
11366 }
11367 if (arg1) (arg1)->m_pid = arg2;
11368
11369 Py_INCREF(Py_None); resultobj = Py_None;
11370 return resultobj;
11371 fail:
11372 return NULL;
11373 }
11374
11375
11376 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11377 PyObject *resultobj;
11378 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11379 int result;
11380 PyObject * obj0 = 0 ;
11381 char *kwnames[] = {
11382 (char *) "self", NULL
11383 };
11384
11385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11387 if (SWIG_arg_fail(1)) SWIG_fail;
11388 result = (int) ((arg1)->m_pid);
11389
11390 {
11391 resultobj = SWIG_From_int((int)(result));
11392 }
11393 return resultobj;
11394 fail:
11395 return NULL;
11396 }
11397
11398
11399 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11400 PyObject *resultobj;
11401 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11402 int arg2 ;
11403 PyObject * obj0 = 0 ;
11404 PyObject * obj1 = 0 ;
11405 char *kwnames[] = {
11406 (char *) "self",(char *) "m_exitcode", NULL
11407 };
11408
11409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11411 if (SWIG_arg_fail(1)) SWIG_fail;
11412 {
11413 arg2 = (int)(SWIG_As_int(obj1));
11414 if (SWIG_arg_fail(2)) SWIG_fail;
11415 }
11416 if (arg1) (arg1)->m_exitcode = arg2;
11417
11418 Py_INCREF(Py_None); resultobj = Py_None;
11419 return resultobj;
11420 fail:
11421 return NULL;
11422 }
11423
11424
11425 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11426 PyObject *resultobj;
11427 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11428 int result;
11429 PyObject * obj0 = 0 ;
11430 char *kwnames[] = {
11431 (char *) "self", NULL
11432 };
11433
11434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11436 if (SWIG_arg_fail(1)) SWIG_fail;
11437 result = (int) ((arg1)->m_exitcode);
11438
11439 {
11440 resultobj = SWIG_From_int((int)(result));
11441 }
11442 return resultobj;
11443 fail:
11444 return NULL;
11445 }
11446
11447
11448 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11449 PyObject *obj;
11450 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11451 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11452 Py_INCREF(obj);
11453 return Py_BuildValue((char *)"");
11454 }
11455 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11456 PyObject *resultobj;
11457 wxString *arg1 = 0 ;
11458 int arg2 = (int) wxEXEC_ASYNC ;
11459 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11460 long result;
11461 bool temp1 = false ;
11462 PyObject * obj0 = 0 ;
11463 PyObject * obj1 = 0 ;
11464 PyObject * obj2 = 0 ;
11465 char *kwnames[] = {
11466 (char *) "command",(char *) "flags",(char *) "process", NULL
11467 };
11468
11469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11470 {
11471 arg1 = wxString_in_helper(obj0);
11472 if (arg1 == NULL) SWIG_fail;
11473 temp1 = true;
11474 }
11475 if (obj1) {
11476 {
11477 arg2 = (int)(SWIG_As_int(obj1));
11478 if (SWIG_arg_fail(2)) SWIG_fail;
11479 }
11480 }
11481 if (obj2) {
11482 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11483 if (SWIG_arg_fail(3)) SWIG_fail;
11484 }
11485 {
11486 if (!wxPyCheckForApp()) SWIG_fail;
11487 PyThreadState* __tstate = wxPyBeginAllowThreads();
11488 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11489
11490 wxPyEndAllowThreads(__tstate);
11491 if (PyErr_Occurred()) SWIG_fail;
11492 }
11493 {
11494 resultobj = SWIG_From_long((long)(result));
11495 }
11496 {
11497 if (temp1)
11498 delete arg1;
11499 }
11500 return resultobj;
11501 fail:
11502 {
11503 if (temp1)
11504 delete arg1;
11505 }
11506 return NULL;
11507 }
11508
11509
11510 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11511 PyObject *resultobj;
11512 long arg1 ;
11513 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11514 wxKillError *arg3 = (wxKillError *) 0 ;
11515 int arg4 = (int) wxKILL_NOCHILDREN ;
11516 int result;
11517 wxKillError temp3 ;
11518 PyObject * obj0 = 0 ;
11519 PyObject * obj1 = 0 ;
11520 PyObject * obj2 = 0 ;
11521 char *kwnames[] = {
11522 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11523 };
11524
11525 {
11526 arg3 = &temp3;
11527 }
11528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11529 {
11530 arg1 = (long)(SWIG_As_long(obj0));
11531 if (SWIG_arg_fail(1)) SWIG_fail;
11532 }
11533 if (obj1) {
11534 {
11535 arg2 = (wxSignal)(SWIG_As_int(obj1));
11536 if (SWIG_arg_fail(2)) SWIG_fail;
11537 }
11538 }
11539 if (obj2) {
11540 {
11541 arg4 = (int)(SWIG_As_int(obj2));
11542 if (SWIG_arg_fail(4)) SWIG_fail;
11543 }
11544 }
11545 {
11546 PyThreadState* __tstate = wxPyBeginAllowThreads();
11547 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11548
11549 wxPyEndAllowThreads(__tstate);
11550 if (PyErr_Occurred()) SWIG_fail;
11551 }
11552 {
11553 resultobj = SWIG_From_int((int)(result));
11554 }
11555 {
11556 PyObject* o;
11557 o = PyInt_FromLong((long) (*arg3));
11558 resultobj = t_output_helper(resultobj, o);
11559 }
11560 return resultobj;
11561 fail:
11562 return NULL;
11563 }
11564
11565
11566 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11567 PyObject *resultobj;
11568 int arg1 = (int) wxJOYSTICK1 ;
11569 wxJoystick *result;
11570 PyObject * obj0 = 0 ;
11571 char *kwnames[] = {
11572 (char *) "joystick", NULL
11573 };
11574
11575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11576 if (obj0) {
11577 {
11578 arg1 = (int)(SWIG_As_int(obj0));
11579 if (SWIG_arg_fail(1)) SWIG_fail;
11580 }
11581 }
11582 {
11583 if (!wxPyCheckForApp()) SWIG_fail;
11584 PyThreadState* __tstate = wxPyBeginAllowThreads();
11585 result = (wxJoystick *)new wxJoystick(arg1);
11586
11587 wxPyEndAllowThreads(__tstate);
11588 if (PyErr_Occurred()) SWIG_fail;
11589 }
11590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11591 return resultobj;
11592 fail:
11593 return NULL;
11594 }
11595
11596
11597 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11598 PyObject *resultobj;
11599 wxJoystick *arg1 = (wxJoystick *) 0 ;
11600 PyObject * obj0 = 0 ;
11601 char *kwnames[] = {
11602 (char *) "self", NULL
11603 };
11604
11605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11607 if (SWIG_arg_fail(1)) SWIG_fail;
11608 {
11609 PyThreadState* __tstate = wxPyBeginAllowThreads();
11610 delete arg1;
11611
11612 wxPyEndAllowThreads(__tstate);
11613 if (PyErr_Occurred()) SWIG_fail;
11614 }
11615 Py_INCREF(Py_None); resultobj = Py_None;
11616 return resultobj;
11617 fail:
11618 return NULL;
11619 }
11620
11621
11622 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11623 PyObject *resultobj;
11624 wxJoystick *arg1 = (wxJoystick *) 0 ;
11625 wxPoint result;
11626 PyObject * obj0 = 0 ;
11627 char *kwnames[] = {
11628 (char *) "self", NULL
11629 };
11630
11631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11633 if (SWIG_arg_fail(1)) SWIG_fail;
11634 {
11635 PyThreadState* __tstate = wxPyBeginAllowThreads();
11636 result = (arg1)->GetPosition();
11637
11638 wxPyEndAllowThreads(__tstate);
11639 if (PyErr_Occurred()) SWIG_fail;
11640 }
11641 {
11642 wxPoint * resultptr;
11643 resultptr = new wxPoint((wxPoint &)(result));
11644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11645 }
11646 return resultobj;
11647 fail:
11648 return NULL;
11649 }
11650
11651
11652 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11653 PyObject *resultobj;
11654 wxJoystick *arg1 = (wxJoystick *) 0 ;
11655 int result;
11656 PyObject * obj0 = 0 ;
11657 char *kwnames[] = {
11658 (char *) "self", NULL
11659 };
11660
11661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11663 if (SWIG_arg_fail(1)) SWIG_fail;
11664 {
11665 PyThreadState* __tstate = wxPyBeginAllowThreads();
11666 result = (int)(arg1)->GetZPosition();
11667
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 {
11672 resultobj = SWIG_From_int((int)(result));
11673 }
11674 return resultobj;
11675 fail:
11676 return NULL;
11677 }
11678
11679
11680 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11681 PyObject *resultobj;
11682 wxJoystick *arg1 = (wxJoystick *) 0 ;
11683 int result;
11684 PyObject * obj0 = 0 ;
11685 char *kwnames[] = {
11686 (char *) "self", NULL
11687 };
11688
11689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11691 if (SWIG_arg_fail(1)) SWIG_fail;
11692 {
11693 PyThreadState* __tstate = wxPyBeginAllowThreads();
11694 result = (int)(arg1)->GetButtonState();
11695
11696 wxPyEndAllowThreads(__tstate);
11697 if (PyErr_Occurred()) SWIG_fail;
11698 }
11699 {
11700 resultobj = SWIG_From_int((int)(result));
11701 }
11702 return resultobj;
11703 fail:
11704 return NULL;
11705 }
11706
11707
11708 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11709 PyObject *resultobj;
11710 wxJoystick *arg1 = (wxJoystick *) 0 ;
11711 int result;
11712 PyObject * obj0 = 0 ;
11713 char *kwnames[] = {
11714 (char *) "self", NULL
11715 };
11716
11717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11719 if (SWIG_arg_fail(1)) SWIG_fail;
11720 {
11721 PyThreadState* __tstate = wxPyBeginAllowThreads();
11722 result = (int)(arg1)->GetPOVPosition();
11723
11724 wxPyEndAllowThreads(__tstate);
11725 if (PyErr_Occurred()) SWIG_fail;
11726 }
11727 {
11728 resultobj = SWIG_From_int((int)(result));
11729 }
11730 return resultobj;
11731 fail:
11732 return NULL;
11733 }
11734
11735
11736 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11737 PyObject *resultobj;
11738 wxJoystick *arg1 = (wxJoystick *) 0 ;
11739 int result;
11740 PyObject * obj0 = 0 ;
11741 char *kwnames[] = {
11742 (char *) "self", NULL
11743 };
11744
11745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11747 if (SWIG_arg_fail(1)) SWIG_fail;
11748 {
11749 PyThreadState* __tstate = wxPyBeginAllowThreads();
11750 result = (int)(arg1)->GetPOVCTSPosition();
11751
11752 wxPyEndAllowThreads(__tstate);
11753 if (PyErr_Occurred()) SWIG_fail;
11754 }
11755 {
11756 resultobj = SWIG_From_int((int)(result));
11757 }
11758 return resultobj;
11759 fail:
11760 return NULL;
11761 }
11762
11763
11764 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11765 PyObject *resultobj;
11766 wxJoystick *arg1 = (wxJoystick *) 0 ;
11767 int result;
11768 PyObject * obj0 = 0 ;
11769 char *kwnames[] = {
11770 (char *) "self", NULL
11771 };
11772
11773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11775 if (SWIG_arg_fail(1)) SWIG_fail;
11776 {
11777 PyThreadState* __tstate = wxPyBeginAllowThreads();
11778 result = (int)(arg1)->GetRudderPosition();
11779
11780 wxPyEndAllowThreads(__tstate);
11781 if (PyErr_Occurred()) SWIG_fail;
11782 }
11783 {
11784 resultobj = SWIG_From_int((int)(result));
11785 }
11786 return resultobj;
11787 fail:
11788 return NULL;
11789 }
11790
11791
11792 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11793 PyObject *resultobj;
11794 wxJoystick *arg1 = (wxJoystick *) 0 ;
11795 int result;
11796 PyObject * obj0 = 0 ;
11797 char *kwnames[] = {
11798 (char *) "self", NULL
11799 };
11800
11801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11803 if (SWIG_arg_fail(1)) SWIG_fail;
11804 {
11805 PyThreadState* __tstate = wxPyBeginAllowThreads();
11806 result = (int)(arg1)->GetUPosition();
11807
11808 wxPyEndAllowThreads(__tstate);
11809 if (PyErr_Occurred()) SWIG_fail;
11810 }
11811 {
11812 resultobj = SWIG_From_int((int)(result));
11813 }
11814 return resultobj;
11815 fail:
11816 return NULL;
11817 }
11818
11819
11820 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11821 PyObject *resultobj;
11822 wxJoystick *arg1 = (wxJoystick *) 0 ;
11823 int result;
11824 PyObject * obj0 = 0 ;
11825 char *kwnames[] = {
11826 (char *) "self", NULL
11827 };
11828
11829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11831 if (SWIG_arg_fail(1)) SWIG_fail;
11832 {
11833 PyThreadState* __tstate = wxPyBeginAllowThreads();
11834 result = (int)(arg1)->GetVPosition();
11835
11836 wxPyEndAllowThreads(__tstate);
11837 if (PyErr_Occurred()) SWIG_fail;
11838 }
11839 {
11840 resultobj = SWIG_From_int((int)(result));
11841 }
11842 return resultobj;
11843 fail:
11844 return NULL;
11845 }
11846
11847
11848 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11849 PyObject *resultobj;
11850 wxJoystick *arg1 = (wxJoystick *) 0 ;
11851 int result;
11852 PyObject * obj0 = 0 ;
11853 char *kwnames[] = {
11854 (char *) "self", NULL
11855 };
11856
11857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11859 if (SWIG_arg_fail(1)) SWIG_fail;
11860 {
11861 PyThreadState* __tstate = wxPyBeginAllowThreads();
11862 result = (int)(arg1)->GetMovementThreshold();
11863
11864 wxPyEndAllowThreads(__tstate);
11865 if (PyErr_Occurred()) SWIG_fail;
11866 }
11867 {
11868 resultobj = SWIG_From_int((int)(result));
11869 }
11870 return resultobj;
11871 fail:
11872 return NULL;
11873 }
11874
11875
11876 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11877 PyObject *resultobj;
11878 wxJoystick *arg1 = (wxJoystick *) 0 ;
11879 int arg2 ;
11880 PyObject * obj0 = 0 ;
11881 PyObject * obj1 = 0 ;
11882 char *kwnames[] = {
11883 (char *) "self",(char *) "threshold", NULL
11884 };
11885
11886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11888 if (SWIG_arg_fail(1)) SWIG_fail;
11889 {
11890 arg2 = (int)(SWIG_As_int(obj1));
11891 if (SWIG_arg_fail(2)) SWIG_fail;
11892 }
11893 {
11894 PyThreadState* __tstate = wxPyBeginAllowThreads();
11895 (arg1)->SetMovementThreshold(arg2);
11896
11897 wxPyEndAllowThreads(__tstate);
11898 if (PyErr_Occurred()) SWIG_fail;
11899 }
11900 Py_INCREF(Py_None); resultobj = Py_None;
11901 return resultobj;
11902 fail:
11903 return NULL;
11904 }
11905
11906
11907 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11908 PyObject *resultobj;
11909 wxJoystick *arg1 = (wxJoystick *) 0 ;
11910 bool result;
11911 PyObject * obj0 = 0 ;
11912 char *kwnames[] = {
11913 (char *) "self", NULL
11914 };
11915
11916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11918 if (SWIG_arg_fail(1)) SWIG_fail;
11919 {
11920 PyThreadState* __tstate = wxPyBeginAllowThreads();
11921 result = (bool)(arg1)->IsOk();
11922
11923 wxPyEndAllowThreads(__tstate);
11924 if (PyErr_Occurred()) SWIG_fail;
11925 }
11926 {
11927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11928 }
11929 return resultobj;
11930 fail:
11931 return NULL;
11932 }
11933
11934
11935 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11936 PyObject *resultobj;
11937 wxJoystick *arg1 = (wxJoystick *) 0 ;
11938 int result;
11939 PyObject * obj0 = 0 ;
11940 char *kwnames[] = {
11941 (char *) "self", NULL
11942 };
11943
11944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11946 if (SWIG_arg_fail(1)) SWIG_fail;
11947 {
11948 PyThreadState* __tstate = wxPyBeginAllowThreads();
11949 result = (int)(arg1)->GetNumberJoysticks();
11950
11951 wxPyEndAllowThreads(__tstate);
11952 if (PyErr_Occurred()) SWIG_fail;
11953 }
11954 {
11955 resultobj = SWIG_From_int((int)(result));
11956 }
11957 return resultobj;
11958 fail:
11959 return NULL;
11960 }
11961
11962
11963 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11964 PyObject *resultobj;
11965 wxJoystick *arg1 = (wxJoystick *) 0 ;
11966 int result;
11967 PyObject * obj0 = 0 ;
11968 char *kwnames[] = {
11969 (char *) "self", NULL
11970 };
11971
11972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11974 if (SWIG_arg_fail(1)) SWIG_fail;
11975 {
11976 PyThreadState* __tstate = wxPyBeginAllowThreads();
11977 result = (int)(arg1)->GetManufacturerId();
11978
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 {
11983 resultobj = SWIG_From_int((int)(result));
11984 }
11985 return resultobj;
11986 fail:
11987 return NULL;
11988 }
11989
11990
11991 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11992 PyObject *resultobj;
11993 wxJoystick *arg1 = (wxJoystick *) 0 ;
11994 int result;
11995 PyObject * obj0 = 0 ;
11996 char *kwnames[] = {
11997 (char *) "self", NULL
11998 };
11999
12000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12002 if (SWIG_arg_fail(1)) SWIG_fail;
12003 {
12004 PyThreadState* __tstate = wxPyBeginAllowThreads();
12005 result = (int)(arg1)->GetProductId();
12006
12007 wxPyEndAllowThreads(__tstate);
12008 if (PyErr_Occurred()) SWIG_fail;
12009 }
12010 {
12011 resultobj = SWIG_From_int((int)(result));
12012 }
12013 return resultobj;
12014 fail:
12015 return NULL;
12016 }
12017
12018
12019 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12020 PyObject *resultobj;
12021 wxJoystick *arg1 = (wxJoystick *) 0 ;
12022 wxString result;
12023 PyObject * obj0 = 0 ;
12024 char *kwnames[] = {
12025 (char *) "self", NULL
12026 };
12027
12028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12030 if (SWIG_arg_fail(1)) SWIG_fail;
12031 {
12032 PyThreadState* __tstate = wxPyBeginAllowThreads();
12033 result = (arg1)->GetProductName();
12034
12035 wxPyEndAllowThreads(__tstate);
12036 if (PyErr_Occurred()) SWIG_fail;
12037 }
12038 {
12039 #if wxUSE_UNICODE
12040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12041 #else
12042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12043 #endif
12044 }
12045 return resultobj;
12046 fail:
12047 return NULL;
12048 }
12049
12050
12051 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12052 PyObject *resultobj;
12053 wxJoystick *arg1 = (wxJoystick *) 0 ;
12054 int result;
12055 PyObject * obj0 = 0 ;
12056 char *kwnames[] = {
12057 (char *) "self", NULL
12058 };
12059
12060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12062 if (SWIG_arg_fail(1)) SWIG_fail;
12063 {
12064 PyThreadState* __tstate = wxPyBeginAllowThreads();
12065 result = (int)(arg1)->GetXMin();
12066
12067 wxPyEndAllowThreads(__tstate);
12068 if (PyErr_Occurred()) SWIG_fail;
12069 }
12070 {
12071 resultobj = SWIG_From_int((int)(result));
12072 }
12073 return resultobj;
12074 fail:
12075 return NULL;
12076 }
12077
12078
12079 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12080 PyObject *resultobj;
12081 wxJoystick *arg1 = (wxJoystick *) 0 ;
12082 int result;
12083 PyObject * obj0 = 0 ;
12084 char *kwnames[] = {
12085 (char *) "self", NULL
12086 };
12087
12088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12090 if (SWIG_arg_fail(1)) SWIG_fail;
12091 {
12092 PyThreadState* __tstate = wxPyBeginAllowThreads();
12093 result = (int)(arg1)->GetYMin();
12094
12095 wxPyEndAllowThreads(__tstate);
12096 if (PyErr_Occurred()) SWIG_fail;
12097 }
12098 {
12099 resultobj = SWIG_From_int((int)(result));
12100 }
12101 return resultobj;
12102 fail:
12103 return NULL;
12104 }
12105
12106
12107 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12108 PyObject *resultobj;
12109 wxJoystick *arg1 = (wxJoystick *) 0 ;
12110 int result;
12111 PyObject * obj0 = 0 ;
12112 char *kwnames[] = {
12113 (char *) "self", NULL
12114 };
12115
12116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12118 if (SWIG_arg_fail(1)) SWIG_fail;
12119 {
12120 PyThreadState* __tstate = wxPyBeginAllowThreads();
12121 result = (int)(arg1)->GetZMin();
12122
12123 wxPyEndAllowThreads(__tstate);
12124 if (PyErr_Occurred()) SWIG_fail;
12125 }
12126 {
12127 resultobj = SWIG_From_int((int)(result));
12128 }
12129 return resultobj;
12130 fail:
12131 return NULL;
12132 }
12133
12134
12135 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12136 PyObject *resultobj;
12137 wxJoystick *arg1 = (wxJoystick *) 0 ;
12138 int result;
12139 PyObject * obj0 = 0 ;
12140 char *kwnames[] = {
12141 (char *) "self", NULL
12142 };
12143
12144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12146 if (SWIG_arg_fail(1)) SWIG_fail;
12147 {
12148 PyThreadState* __tstate = wxPyBeginAllowThreads();
12149 result = (int)(arg1)->GetXMax();
12150
12151 wxPyEndAllowThreads(__tstate);
12152 if (PyErr_Occurred()) SWIG_fail;
12153 }
12154 {
12155 resultobj = SWIG_From_int((int)(result));
12156 }
12157 return resultobj;
12158 fail:
12159 return NULL;
12160 }
12161
12162
12163 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12164 PyObject *resultobj;
12165 wxJoystick *arg1 = (wxJoystick *) 0 ;
12166 int result;
12167 PyObject * obj0 = 0 ;
12168 char *kwnames[] = {
12169 (char *) "self", NULL
12170 };
12171
12172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12174 if (SWIG_arg_fail(1)) SWIG_fail;
12175 {
12176 PyThreadState* __tstate = wxPyBeginAllowThreads();
12177 result = (int)(arg1)->GetYMax();
12178
12179 wxPyEndAllowThreads(__tstate);
12180 if (PyErr_Occurred()) SWIG_fail;
12181 }
12182 {
12183 resultobj = SWIG_From_int((int)(result));
12184 }
12185 return resultobj;
12186 fail:
12187 return NULL;
12188 }
12189
12190
12191 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12192 PyObject *resultobj;
12193 wxJoystick *arg1 = (wxJoystick *) 0 ;
12194 int result;
12195 PyObject * obj0 = 0 ;
12196 char *kwnames[] = {
12197 (char *) "self", NULL
12198 };
12199
12200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12202 if (SWIG_arg_fail(1)) SWIG_fail;
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 result = (int)(arg1)->GetZMax();
12206
12207 wxPyEndAllowThreads(__tstate);
12208 if (PyErr_Occurred()) SWIG_fail;
12209 }
12210 {
12211 resultobj = SWIG_From_int((int)(result));
12212 }
12213 return resultobj;
12214 fail:
12215 return NULL;
12216 }
12217
12218
12219 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12220 PyObject *resultobj;
12221 wxJoystick *arg1 = (wxJoystick *) 0 ;
12222 int result;
12223 PyObject * obj0 = 0 ;
12224 char *kwnames[] = {
12225 (char *) "self", NULL
12226 };
12227
12228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12230 if (SWIG_arg_fail(1)) SWIG_fail;
12231 {
12232 PyThreadState* __tstate = wxPyBeginAllowThreads();
12233 result = (int)(arg1)->GetNumberButtons();
12234
12235 wxPyEndAllowThreads(__tstate);
12236 if (PyErr_Occurred()) SWIG_fail;
12237 }
12238 {
12239 resultobj = SWIG_From_int((int)(result));
12240 }
12241 return resultobj;
12242 fail:
12243 return NULL;
12244 }
12245
12246
12247 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12248 PyObject *resultobj;
12249 wxJoystick *arg1 = (wxJoystick *) 0 ;
12250 int result;
12251 PyObject * obj0 = 0 ;
12252 char *kwnames[] = {
12253 (char *) "self", NULL
12254 };
12255
12256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12258 if (SWIG_arg_fail(1)) SWIG_fail;
12259 {
12260 PyThreadState* __tstate = wxPyBeginAllowThreads();
12261 result = (int)(arg1)->GetNumberAxes();
12262
12263 wxPyEndAllowThreads(__tstate);
12264 if (PyErr_Occurred()) SWIG_fail;
12265 }
12266 {
12267 resultobj = SWIG_From_int((int)(result));
12268 }
12269 return resultobj;
12270 fail:
12271 return NULL;
12272 }
12273
12274
12275 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12276 PyObject *resultobj;
12277 wxJoystick *arg1 = (wxJoystick *) 0 ;
12278 int result;
12279 PyObject * obj0 = 0 ;
12280 char *kwnames[] = {
12281 (char *) "self", NULL
12282 };
12283
12284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12286 if (SWIG_arg_fail(1)) SWIG_fail;
12287 {
12288 PyThreadState* __tstate = wxPyBeginAllowThreads();
12289 result = (int)(arg1)->GetMaxButtons();
12290
12291 wxPyEndAllowThreads(__tstate);
12292 if (PyErr_Occurred()) SWIG_fail;
12293 }
12294 {
12295 resultobj = SWIG_From_int((int)(result));
12296 }
12297 return resultobj;
12298 fail:
12299 return NULL;
12300 }
12301
12302
12303 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12304 PyObject *resultobj;
12305 wxJoystick *arg1 = (wxJoystick *) 0 ;
12306 int result;
12307 PyObject * obj0 = 0 ;
12308 char *kwnames[] = {
12309 (char *) "self", NULL
12310 };
12311
12312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12314 if (SWIG_arg_fail(1)) SWIG_fail;
12315 {
12316 PyThreadState* __tstate = wxPyBeginAllowThreads();
12317 result = (int)(arg1)->GetMaxAxes();
12318
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 {
12323 resultobj = SWIG_From_int((int)(result));
12324 }
12325 return resultobj;
12326 fail:
12327 return NULL;
12328 }
12329
12330
12331 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12332 PyObject *resultobj;
12333 wxJoystick *arg1 = (wxJoystick *) 0 ;
12334 int result;
12335 PyObject * obj0 = 0 ;
12336 char *kwnames[] = {
12337 (char *) "self", NULL
12338 };
12339
12340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12342 if (SWIG_arg_fail(1)) SWIG_fail;
12343 {
12344 PyThreadState* __tstate = wxPyBeginAllowThreads();
12345 result = (int)(arg1)->GetPollingMin();
12346
12347 wxPyEndAllowThreads(__tstate);
12348 if (PyErr_Occurred()) SWIG_fail;
12349 }
12350 {
12351 resultobj = SWIG_From_int((int)(result));
12352 }
12353 return resultobj;
12354 fail:
12355 return NULL;
12356 }
12357
12358
12359 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12360 PyObject *resultobj;
12361 wxJoystick *arg1 = (wxJoystick *) 0 ;
12362 int result;
12363 PyObject * obj0 = 0 ;
12364 char *kwnames[] = {
12365 (char *) "self", NULL
12366 };
12367
12368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12370 if (SWIG_arg_fail(1)) SWIG_fail;
12371 {
12372 PyThreadState* __tstate = wxPyBeginAllowThreads();
12373 result = (int)(arg1)->GetPollingMax();
12374
12375 wxPyEndAllowThreads(__tstate);
12376 if (PyErr_Occurred()) SWIG_fail;
12377 }
12378 {
12379 resultobj = SWIG_From_int((int)(result));
12380 }
12381 return resultobj;
12382 fail:
12383 return NULL;
12384 }
12385
12386
12387 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12388 PyObject *resultobj;
12389 wxJoystick *arg1 = (wxJoystick *) 0 ;
12390 int result;
12391 PyObject * obj0 = 0 ;
12392 char *kwnames[] = {
12393 (char *) "self", NULL
12394 };
12395
12396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12398 if (SWIG_arg_fail(1)) SWIG_fail;
12399 {
12400 PyThreadState* __tstate = wxPyBeginAllowThreads();
12401 result = (int)(arg1)->GetRudderMin();
12402
12403 wxPyEndAllowThreads(__tstate);
12404 if (PyErr_Occurred()) SWIG_fail;
12405 }
12406 {
12407 resultobj = SWIG_From_int((int)(result));
12408 }
12409 return resultobj;
12410 fail:
12411 return NULL;
12412 }
12413
12414
12415 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12416 PyObject *resultobj;
12417 wxJoystick *arg1 = (wxJoystick *) 0 ;
12418 int result;
12419 PyObject * obj0 = 0 ;
12420 char *kwnames[] = {
12421 (char *) "self", NULL
12422 };
12423
12424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12426 if (SWIG_arg_fail(1)) SWIG_fail;
12427 {
12428 PyThreadState* __tstate = wxPyBeginAllowThreads();
12429 result = (int)(arg1)->GetRudderMax();
12430
12431 wxPyEndAllowThreads(__tstate);
12432 if (PyErr_Occurred()) SWIG_fail;
12433 }
12434 {
12435 resultobj = SWIG_From_int((int)(result));
12436 }
12437 return resultobj;
12438 fail:
12439 return NULL;
12440 }
12441
12442
12443 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12444 PyObject *resultobj;
12445 wxJoystick *arg1 = (wxJoystick *) 0 ;
12446 int result;
12447 PyObject * obj0 = 0 ;
12448 char *kwnames[] = {
12449 (char *) "self", NULL
12450 };
12451
12452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12454 if (SWIG_arg_fail(1)) SWIG_fail;
12455 {
12456 PyThreadState* __tstate = wxPyBeginAllowThreads();
12457 result = (int)(arg1)->GetUMin();
12458
12459 wxPyEndAllowThreads(__tstate);
12460 if (PyErr_Occurred()) SWIG_fail;
12461 }
12462 {
12463 resultobj = SWIG_From_int((int)(result));
12464 }
12465 return resultobj;
12466 fail:
12467 return NULL;
12468 }
12469
12470
12471 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12472 PyObject *resultobj;
12473 wxJoystick *arg1 = (wxJoystick *) 0 ;
12474 int result;
12475 PyObject * obj0 = 0 ;
12476 char *kwnames[] = {
12477 (char *) "self", NULL
12478 };
12479
12480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12482 if (SWIG_arg_fail(1)) SWIG_fail;
12483 {
12484 PyThreadState* __tstate = wxPyBeginAllowThreads();
12485 result = (int)(arg1)->GetUMax();
12486
12487 wxPyEndAllowThreads(__tstate);
12488 if (PyErr_Occurred()) SWIG_fail;
12489 }
12490 {
12491 resultobj = SWIG_From_int((int)(result));
12492 }
12493 return resultobj;
12494 fail:
12495 return NULL;
12496 }
12497
12498
12499 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12500 PyObject *resultobj;
12501 wxJoystick *arg1 = (wxJoystick *) 0 ;
12502 int result;
12503 PyObject * obj0 = 0 ;
12504 char *kwnames[] = {
12505 (char *) "self", NULL
12506 };
12507
12508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12510 if (SWIG_arg_fail(1)) SWIG_fail;
12511 {
12512 PyThreadState* __tstate = wxPyBeginAllowThreads();
12513 result = (int)(arg1)->GetVMin();
12514
12515 wxPyEndAllowThreads(__tstate);
12516 if (PyErr_Occurred()) SWIG_fail;
12517 }
12518 {
12519 resultobj = SWIG_From_int((int)(result));
12520 }
12521 return resultobj;
12522 fail:
12523 return NULL;
12524 }
12525
12526
12527 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12528 PyObject *resultobj;
12529 wxJoystick *arg1 = (wxJoystick *) 0 ;
12530 int result;
12531 PyObject * obj0 = 0 ;
12532 char *kwnames[] = {
12533 (char *) "self", NULL
12534 };
12535
12536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12538 if (SWIG_arg_fail(1)) SWIG_fail;
12539 {
12540 PyThreadState* __tstate = wxPyBeginAllowThreads();
12541 result = (int)(arg1)->GetVMax();
12542
12543 wxPyEndAllowThreads(__tstate);
12544 if (PyErr_Occurred()) SWIG_fail;
12545 }
12546 {
12547 resultobj = SWIG_From_int((int)(result));
12548 }
12549 return resultobj;
12550 fail:
12551 return NULL;
12552 }
12553
12554
12555 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12556 PyObject *resultobj;
12557 wxJoystick *arg1 = (wxJoystick *) 0 ;
12558 bool result;
12559 PyObject * obj0 = 0 ;
12560 char *kwnames[] = {
12561 (char *) "self", NULL
12562 };
12563
12564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12566 if (SWIG_arg_fail(1)) SWIG_fail;
12567 {
12568 PyThreadState* __tstate = wxPyBeginAllowThreads();
12569 result = (bool)(arg1)->HasRudder();
12570
12571 wxPyEndAllowThreads(__tstate);
12572 if (PyErr_Occurred()) SWIG_fail;
12573 }
12574 {
12575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12576 }
12577 return resultobj;
12578 fail:
12579 return NULL;
12580 }
12581
12582
12583 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12584 PyObject *resultobj;
12585 wxJoystick *arg1 = (wxJoystick *) 0 ;
12586 bool result;
12587 PyObject * obj0 = 0 ;
12588 char *kwnames[] = {
12589 (char *) "self", NULL
12590 };
12591
12592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12594 if (SWIG_arg_fail(1)) SWIG_fail;
12595 {
12596 PyThreadState* __tstate = wxPyBeginAllowThreads();
12597 result = (bool)(arg1)->HasZ();
12598
12599 wxPyEndAllowThreads(__tstate);
12600 if (PyErr_Occurred()) SWIG_fail;
12601 }
12602 {
12603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12604 }
12605 return resultobj;
12606 fail:
12607 return NULL;
12608 }
12609
12610
12611 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12612 PyObject *resultobj;
12613 wxJoystick *arg1 = (wxJoystick *) 0 ;
12614 bool result;
12615 PyObject * obj0 = 0 ;
12616 char *kwnames[] = {
12617 (char *) "self", NULL
12618 };
12619
12620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12622 if (SWIG_arg_fail(1)) SWIG_fail;
12623 {
12624 PyThreadState* __tstate = wxPyBeginAllowThreads();
12625 result = (bool)(arg1)->HasU();
12626
12627 wxPyEndAllowThreads(__tstate);
12628 if (PyErr_Occurred()) SWIG_fail;
12629 }
12630 {
12631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12632 }
12633 return resultobj;
12634 fail:
12635 return NULL;
12636 }
12637
12638
12639 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12640 PyObject *resultobj;
12641 wxJoystick *arg1 = (wxJoystick *) 0 ;
12642 bool result;
12643 PyObject * obj0 = 0 ;
12644 char *kwnames[] = {
12645 (char *) "self", NULL
12646 };
12647
12648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12650 if (SWIG_arg_fail(1)) SWIG_fail;
12651 {
12652 PyThreadState* __tstate = wxPyBeginAllowThreads();
12653 result = (bool)(arg1)->HasV();
12654
12655 wxPyEndAllowThreads(__tstate);
12656 if (PyErr_Occurred()) SWIG_fail;
12657 }
12658 {
12659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12660 }
12661 return resultobj;
12662 fail:
12663 return NULL;
12664 }
12665
12666
12667 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12668 PyObject *resultobj;
12669 wxJoystick *arg1 = (wxJoystick *) 0 ;
12670 bool result;
12671 PyObject * obj0 = 0 ;
12672 char *kwnames[] = {
12673 (char *) "self", NULL
12674 };
12675
12676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12678 if (SWIG_arg_fail(1)) SWIG_fail;
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 result = (bool)(arg1)->HasPOV();
12682
12683 wxPyEndAllowThreads(__tstate);
12684 if (PyErr_Occurred()) SWIG_fail;
12685 }
12686 {
12687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12688 }
12689 return resultobj;
12690 fail:
12691 return NULL;
12692 }
12693
12694
12695 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12696 PyObject *resultobj;
12697 wxJoystick *arg1 = (wxJoystick *) 0 ;
12698 bool result;
12699 PyObject * obj0 = 0 ;
12700 char *kwnames[] = {
12701 (char *) "self", NULL
12702 };
12703
12704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12706 if (SWIG_arg_fail(1)) SWIG_fail;
12707 {
12708 PyThreadState* __tstate = wxPyBeginAllowThreads();
12709 result = (bool)(arg1)->HasPOV4Dir();
12710
12711 wxPyEndAllowThreads(__tstate);
12712 if (PyErr_Occurred()) SWIG_fail;
12713 }
12714 {
12715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12716 }
12717 return resultobj;
12718 fail:
12719 return NULL;
12720 }
12721
12722
12723 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12724 PyObject *resultobj;
12725 wxJoystick *arg1 = (wxJoystick *) 0 ;
12726 bool result;
12727 PyObject * obj0 = 0 ;
12728 char *kwnames[] = {
12729 (char *) "self", NULL
12730 };
12731
12732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12734 if (SWIG_arg_fail(1)) SWIG_fail;
12735 {
12736 PyThreadState* __tstate = wxPyBeginAllowThreads();
12737 result = (bool)(arg1)->HasPOVCTS();
12738
12739 wxPyEndAllowThreads(__tstate);
12740 if (PyErr_Occurred()) SWIG_fail;
12741 }
12742 {
12743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12744 }
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12752 PyObject *resultobj;
12753 wxJoystick *arg1 = (wxJoystick *) 0 ;
12754 wxWindow *arg2 = (wxWindow *) 0 ;
12755 int arg3 = (int) 0 ;
12756 bool result;
12757 PyObject * obj0 = 0 ;
12758 PyObject * obj1 = 0 ;
12759 PyObject * obj2 = 0 ;
12760 char *kwnames[] = {
12761 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12762 };
12763
12764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12766 if (SWIG_arg_fail(1)) SWIG_fail;
12767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12768 if (SWIG_arg_fail(2)) SWIG_fail;
12769 if (obj2) {
12770 {
12771 arg3 = (int)(SWIG_As_int(obj2));
12772 if (SWIG_arg_fail(3)) SWIG_fail;
12773 }
12774 }
12775 {
12776 PyThreadState* __tstate = wxPyBeginAllowThreads();
12777 result = (bool)(arg1)->SetCapture(arg2,arg3);
12778
12779 wxPyEndAllowThreads(__tstate);
12780 if (PyErr_Occurred()) SWIG_fail;
12781 }
12782 {
12783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12784 }
12785 return resultobj;
12786 fail:
12787 return NULL;
12788 }
12789
12790
12791 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12792 PyObject *resultobj;
12793 wxJoystick *arg1 = (wxJoystick *) 0 ;
12794 bool result;
12795 PyObject * obj0 = 0 ;
12796 char *kwnames[] = {
12797 (char *) "self", NULL
12798 };
12799
12800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12802 if (SWIG_arg_fail(1)) SWIG_fail;
12803 {
12804 PyThreadState* __tstate = wxPyBeginAllowThreads();
12805 result = (bool)(arg1)->ReleaseCapture();
12806
12807 wxPyEndAllowThreads(__tstate);
12808 if (PyErr_Occurred()) SWIG_fail;
12809 }
12810 {
12811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12812 }
12813 return resultobj;
12814 fail:
12815 return NULL;
12816 }
12817
12818
12819 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12820 PyObject *obj;
12821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12822 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12823 Py_INCREF(obj);
12824 return Py_BuildValue((char *)"");
12825 }
12826 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12827 PyObject *resultobj;
12828 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12829 int arg2 = (int) 0 ;
12830 int arg3 = (int) wxJOYSTICK1 ;
12831 int arg4 = (int) 0 ;
12832 wxJoystickEvent *result;
12833 PyObject * obj0 = 0 ;
12834 PyObject * obj1 = 0 ;
12835 PyObject * obj2 = 0 ;
12836 PyObject * obj3 = 0 ;
12837 char *kwnames[] = {
12838 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12839 };
12840
12841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12842 if (obj0) {
12843 {
12844 arg1 = (wxEventType)(SWIG_As_int(obj0));
12845 if (SWIG_arg_fail(1)) SWIG_fail;
12846 }
12847 }
12848 if (obj1) {
12849 {
12850 arg2 = (int)(SWIG_As_int(obj1));
12851 if (SWIG_arg_fail(2)) SWIG_fail;
12852 }
12853 }
12854 if (obj2) {
12855 {
12856 arg3 = (int)(SWIG_As_int(obj2));
12857 if (SWIG_arg_fail(3)) SWIG_fail;
12858 }
12859 }
12860 if (obj3) {
12861 {
12862 arg4 = (int)(SWIG_As_int(obj3));
12863 if (SWIG_arg_fail(4)) SWIG_fail;
12864 }
12865 }
12866 {
12867 PyThreadState* __tstate = wxPyBeginAllowThreads();
12868 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12869
12870 wxPyEndAllowThreads(__tstate);
12871 if (PyErr_Occurred()) SWIG_fail;
12872 }
12873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12874 return resultobj;
12875 fail:
12876 return NULL;
12877 }
12878
12879
12880 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12881 PyObject *resultobj;
12882 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12883 wxPoint result;
12884 PyObject * obj0 = 0 ;
12885 char *kwnames[] = {
12886 (char *) "self", NULL
12887 };
12888
12889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12891 if (SWIG_arg_fail(1)) SWIG_fail;
12892 {
12893 PyThreadState* __tstate = wxPyBeginAllowThreads();
12894 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12895
12896 wxPyEndAllowThreads(__tstate);
12897 if (PyErr_Occurred()) SWIG_fail;
12898 }
12899 {
12900 wxPoint * resultptr;
12901 resultptr = new wxPoint((wxPoint &)(result));
12902 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12903 }
12904 return resultobj;
12905 fail:
12906 return NULL;
12907 }
12908
12909
12910 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12911 PyObject *resultobj;
12912 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12913 int result;
12914 PyObject * obj0 = 0 ;
12915 char *kwnames[] = {
12916 (char *) "self", NULL
12917 };
12918
12919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12921 if (SWIG_arg_fail(1)) SWIG_fail;
12922 {
12923 PyThreadState* __tstate = wxPyBeginAllowThreads();
12924 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12925
12926 wxPyEndAllowThreads(__tstate);
12927 if (PyErr_Occurred()) SWIG_fail;
12928 }
12929 {
12930 resultobj = SWIG_From_int((int)(result));
12931 }
12932 return resultobj;
12933 fail:
12934 return NULL;
12935 }
12936
12937
12938 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12939 PyObject *resultobj;
12940 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12941 int result;
12942 PyObject * obj0 = 0 ;
12943 char *kwnames[] = {
12944 (char *) "self", NULL
12945 };
12946
12947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12949 if (SWIG_arg_fail(1)) SWIG_fail;
12950 {
12951 PyThreadState* __tstate = wxPyBeginAllowThreads();
12952 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12953
12954 wxPyEndAllowThreads(__tstate);
12955 if (PyErr_Occurred()) SWIG_fail;
12956 }
12957 {
12958 resultobj = SWIG_From_int((int)(result));
12959 }
12960 return resultobj;
12961 fail:
12962 return NULL;
12963 }
12964
12965
12966 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12967 PyObject *resultobj;
12968 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12969 int result;
12970 PyObject * obj0 = 0 ;
12971 char *kwnames[] = {
12972 (char *) "self", NULL
12973 };
12974
12975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12977 if (SWIG_arg_fail(1)) SWIG_fail;
12978 {
12979 PyThreadState* __tstate = wxPyBeginAllowThreads();
12980 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12981
12982 wxPyEndAllowThreads(__tstate);
12983 if (PyErr_Occurred()) SWIG_fail;
12984 }
12985 {
12986 resultobj = SWIG_From_int((int)(result));
12987 }
12988 return resultobj;
12989 fail:
12990 return NULL;
12991 }
12992
12993
12994 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12995 PyObject *resultobj;
12996 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12997 int result;
12998 PyObject * obj0 = 0 ;
12999 char *kwnames[] = {
13000 (char *) "self", NULL
13001 };
13002
13003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13005 if (SWIG_arg_fail(1)) SWIG_fail;
13006 {
13007 PyThreadState* __tstate = wxPyBeginAllowThreads();
13008 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13009
13010 wxPyEndAllowThreads(__tstate);
13011 if (PyErr_Occurred()) SWIG_fail;
13012 }
13013 {
13014 resultobj = SWIG_From_int((int)(result));
13015 }
13016 return resultobj;
13017 fail:
13018 return NULL;
13019 }
13020
13021
13022 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13023 PyObject *resultobj;
13024 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13025 int arg2 ;
13026 PyObject * obj0 = 0 ;
13027 PyObject * obj1 = 0 ;
13028 char *kwnames[] = {
13029 (char *) "self",(char *) "stick", NULL
13030 };
13031
13032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13034 if (SWIG_arg_fail(1)) SWIG_fail;
13035 {
13036 arg2 = (int)(SWIG_As_int(obj1));
13037 if (SWIG_arg_fail(2)) SWIG_fail;
13038 }
13039 {
13040 PyThreadState* __tstate = wxPyBeginAllowThreads();
13041 (arg1)->SetJoystick(arg2);
13042
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 Py_INCREF(Py_None); resultobj = Py_None;
13047 return resultobj;
13048 fail:
13049 return NULL;
13050 }
13051
13052
13053 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13054 PyObject *resultobj;
13055 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13056 int arg2 ;
13057 PyObject * obj0 = 0 ;
13058 PyObject * obj1 = 0 ;
13059 char *kwnames[] = {
13060 (char *) "self",(char *) "state", NULL
13061 };
13062
13063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13065 if (SWIG_arg_fail(1)) SWIG_fail;
13066 {
13067 arg2 = (int)(SWIG_As_int(obj1));
13068 if (SWIG_arg_fail(2)) SWIG_fail;
13069 }
13070 {
13071 PyThreadState* __tstate = wxPyBeginAllowThreads();
13072 (arg1)->SetButtonState(arg2);
13073
13074 wxPyEndAllowThreads(__tstate);
13075 if (PyErr_Occurred()) SWIG_fail;
13076 }
13077 Py_INCREF(Py_None); resultobj = Py_None;
13078 return resultobj;
13079 fail:
13080 return NULL;
13081 }
13082
13083
13084 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13085 PyObject *resultobj;
13086 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13087 int arg2 ;
13088 PyObject * obj0 = 0 ;
13089 PyObject * obj1 = 0 ;
13090 char *kwnames[] = {
13091 (char *) "self",(char *) "change", NULL
13092 };
13093
13094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13096 if (SWIG_arg_fail(1)) SWIG_fail;
13097 {
13098 arg2 = (int)(SWIG_As_int(obj1));
13099 if (SWIG_arg_fail(2)) SWIG_fail;
13100 }
13101 {
13102 PyThreadState* __tstate = wxPyBeginAllowThreads();
13103 (arg1)->SetButtonChange(arg2);
13104
13105 wxPyEndAllowThreads(__tstate);
13106 if (PyErr_Occurred()) SWIG_fail;
13107 }
13108 Py_INCREF(Py_None); resultobj = Py_None;
13109 return resultobj;
13110 fail:
13111 return NULL;
13112 }
13113
13114
13115 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13116 PyObject *resultobj;
13117 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13118 wxPoint *arg2 = 0 ;
13119 wxPoint temp2 ;
13120 PyObject * obj0 = 0 ;
13121 PyObject * obj1 = 0 ;
13122 char *kwnames[] = {
13123 (char *) "self",(char *) "pos", NULL
13124 };
13125
13126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13128 if (SWIG_arg_fail(1)) SWIG_fail;
13129 {
13130 arg2 = &temp2;
13131 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13132 }
13133 {
13134 PyThreadState* __tstate = wxPyBeginAllowThreads();
13135 (arg1)->SetPosition((wxPoint const &)*arg2);
13136
13137 wxPyEndAllowThreads(__tstate);
13138 if (PyErr_Occurred()) SWIG_fail;
13139 }
13140 Py_INCREF(Py_None); resultobj = Py_None;
13141 return resultobj;
13142 fail:
13143 return NULL;
13144 }
13145
13146
13147 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13148 PyObject *resultobj;
13149 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13150 int arg2 ;
13151 PyObject * obj0 = 0 ;
13152 PyObject * obj1 = 0 ;
13153 char *kwnames[] = {
13154 (char *) "self",(char *) "zPos", NULL
13155 };
13156
13157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13159 if (SWIG_arg_fail(1)) SWIG_fail;
13160 {
13161 arg2 = (int)(SWIG_As_int(obj1));
13162 if (SWIG_arg_fail(2)) SWIG_fail;
13163 }
13164 {
13165 PyThreadState* __tstate = wxPyBeginAllowThreads();
13166 (arg1)->SetZPosition(arg2);
13167
13168 wxPyEndAllowThreads(__tstate);
13169 if (PyErr_Occurred()) SWIG_fail;
13170 }
13171 Py_INCREF(Py_None); resultobj = Py_None;
13172 return resultobj;
13173 fail:
13174 return NULL;
13175 }
13176
13177
13178 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13179 PyObject *resultobj;
13180 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13181 bool result;
13182 PyObject * obj0 = 0 ;
13183 char *kwnames[] = {
13184 (char *) "self", NULL
13185 };
13186
13187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13189 if (SWIG_arg_fail(1)) SWIG_fail;
13190 {
13191 PyThreadState* __tstate = wxPyBeginAllowThreads();
13192 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13193
13194 wxPyEndAllowThreads(__tstate);
13195 if (PyErr_Occurred()) SWIG_fail;
13196 }
13197 {
13198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13199 }
13200 return resultobj;
13201 fail:
13202 return NULL;
13203 }
13204
13205
13206 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13207 PyObject *resultobj;
13208 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13209 bool result;
13210 PyObject * obj0 = 0 ;
13211 char *kwnames[] = {
13212 (char *) "self", NULL
13213 };
13214
13215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13217 if (SWIG_arg_fail(1)) SWIG_fail;
13218 {
13219 PyThreadState* __tstate = wxPyBeginAllowThreads();
13220 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13221
13222 wxPyEndAllowThreads(__tstate);
13223 if (PyErr_Occurred()) SWIG_fail;
13224 }
13225 {
13226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13227 }
13228 return resultobj;
13229 fail:
13230 return NULL;
13231 }
13232
13233
13234 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13235 PyObject *resultobj;
13236 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13237 bool result;
13238 PyObject * obj0 = 0 ;
13239 char *kwnames[] = {
13240 (char *) "self", NULL
13241 };
13242
13243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13245 if (SWIG_arg_fail(1)) SWIG_fail;
13246 {
13247 PyThreadState* __tstate = wxPyBeginAllowThreads();
13248 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13249
13250 wxPyEndAllowThreads(__tstate);
13251 if (PyErr_Occurred()) SWIG_fail;
13252 }
13253 {
13254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13255 }
13256 return resultobj;
13257 fail:
13258 return NULL;
13259 }
13260
13261
13262 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13263 PyObject *resultobj;
13264 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13265 int arg2 = (int) wxJOY_BUTTON_ANY ;
13266 bool result;
13267 PyObject * obj0 = 0 ;
13268 PyObject * obj1 = 0 ;
13269 char *kwnames[] = {
13270 (char *) "self",(char *) "but", NULL
13271 };
13272
13273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13275 if (SWIG_arg_fail(1)) SWIG_fail;
13276 if (obj1) {
13277 {
13278 arg2 = (int)(SWIG_As_int(obj1));
13279 if (SWIG_arg_fail(2)) SWIG_fail;
13280 }
13281 }
13282 {
13283 PyThreadState* __tstate = wxPyBeginAllowThreads();
13284 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13285
13286 wxPyEndAllowThreads(__tstate);
13287 if (PyErr_Occurred()) SWIG_fail;
13288 }
13289 {
13290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13291 }
13292 return resultobj;
13293 fail:
13294 return NULL;
13295 }
13296
13297
13298 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13299 PyObject *resultobj;
13300 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13301 int arg2 = (int) wxJOY_BUTTON_ANY ;
13302 bool result;
13303 PyObject * obj0 = 0 ;
13304 PyObject * obj1 = 0 ;
13305 char *kwnames[] = {
13306 (char *) "self",(char *) "but", NULL
13307 };
13308
13309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13311 if (SWIG_arg_fail(1)) SWIG_fail;
13312 if (obj1) {
13313 {
13314 arg2 = (int)(SWIG_As_int(obj1));
13315 if (SWIG_arg_fail(2)) SWIG_fail;
13316 }
13317 }
13318 {
13319 PyThreadState* __tstate = wxPyBeginAllowThreads();
13320 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13321
13322 wxPyEndAllowThreads(__tstate);
13323 if (PyErr_Occurred()) SWIG_fail;
13324 }
13325 {
13326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13327 }
13328 return resultobj;
13329 fail:
13330 return NULL;
13331 }
13332
13333
13334 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13335 PyObject *resultobj;
13336 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13337 int arg2 = (int) wxJOY_BUTTON_ANY ;
13338 bool result;
13339 PyObject * obj0 = 0 ;
13340 PyObject * obj1 = 0 ;
13341 char *kwnames[] = {
13342 (char *) "self",(char *) "but", NULL
13343 };
13344
13345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13347 if (SWIG_arg_fail(1)) SWIG_fail;
13348 if (obj1) {
13349 {
13350 arg2 = (int)(SWIG_As_int(obj1));
13351 if (SWIG_arg_fail(2)) SWIG_fail;
13352 }
13353 }
13354 {
13355 PyThreadState* __tstate = wxPyBeginAllowThreads();
13356 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13357
13358 wxPyEndAllowThreads(__tstate);
13359 if (PyErr_Occurred()) SWIG_fail;
13360 }
13361 {
13362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13363 }
13364 return resultobj;
13365 fail:
13366 return NULL;
13367 }
13368
13369
13370 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13371 PyObject *obj;
13372 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13373 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13374 Py_INCREF(obj);
13375 return Py_BuildValue((char *)"");
13376 }
13377 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13378 PyObject *resultobj;
13379 wxString const &arg1_defvalue = wxPyEmptyString ;
13380 wxString *arg1 = (wxString *) &arg1_defvalue ;
13381 wxSound *result;
13382 bool temp1 = false ;
13383 PyObject * obj0 = 0 ;
13384 char *kwnames[] = {
13385 (char *) "fileName", NULL
13386 };
13387
13388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13389 if (obj0) {
13390 {
13391 arg1 = wxString_in_helper(obj0);
13392 if (arg1 == NULL) SWIG_fail;
13393 temp1 = true;
13394 }
13395 }
13396 {
13397 if (!wxPyCheckForApp()) SWIG_fail;
13398 PyThreadState* __tstate = wxPyBeginAllowThreads();
13399 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13400
13401 wxPyEndAllowThreads(__tstate);
13402 if (PyErr_Occurred()) SWIG_fail;
13403 }
13404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13405 {
13406 if (temp1)
13407 delete arg1;
13408 }
13409 return resultobj;
13410 fail:
13411 {
13412 if (temp1)
13413 delete arg1;
13414 }
13415 return NULL;
13416 }
13417
13418
13419 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13420 PyObject *resultobj;
13421 PyObject *arg1 = (PyObject *) 0 ;
13422 wxSound *result;
13423 PyObject * obj0 = 0 ;
13424 char *kwnames[] = {
13425 (char *) "data", NULL
13426 };
13427
13428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13429 arg1 = obj0;
13430 {
13431 if (!wxPyCheckForApp()) SWIG_fail;
13432 PyThreadState* __tstate = wxPyBeginAllowThreads();
13433 result = (wxSound *)new_wxSound(arg1);
13434
13435 wxPyEndAllowThreads(__tstate);
13436 if (PyErr_Occurred()) SWIG_fail;
13437 }
13438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13439 return resultobj;
13440 fail:
13441 return NULL;
13442 }
13443
13444
13445 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13446 PyObject *resultobj;
13447 wxSound *arg1 = (wxSound *) 0 ;
13448 PyObject * obj0 = 0 ;
13449 char *kwnames[] = {
13450 (char *) "self", NULL
13451 };
13452
13453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13455 if (SWIG_arg_fail(1)) SWIG_fail;
13456 {
13457 PyThreadState* __tstate = wxPyBeginAllowThreads();
13458 delete arg1;
13459
13460 wxPyEndAllowThreads(__tstate);
13461 if (PyErr_Occurred()) SWIG_fail;
13462 }
13463 Py_INCREF(Py_None); resultobj = Py_None;
13464 return resultobj;
13465 fail:
13466 return NULL;
13467 }
13468
13469
13470 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13471 PyObject *resultobj;
13472 wxSound *arg1 = (wxSound *) 0 ;
13473 wxString *arg2 = 0 ;
13474 bool result;
13475 bool temp2 = false ;
13476 PyObject * obj0 = 0 ;
13477 PyObject * obj1 = 0 ;
13478 char *kwnames[] = {
13479 (char *) "self",(char *) "fileName", NULL
13480 };
13481
13482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13484 if (SWIG_arg_fail(1)) SWIG_fail;
13485 {
13486 arg2 = wxString_in_helper(obj1);
13487 if (arg2 == NULL) SWIG_fail;
13488 temp2 = true;
13489 }
13490 {
13491 PyThreadState* __tstate = wxPyBeginAllowThreads();
13492 result = (bool)(arg1)->Create((wxString const &)*arg2);
13493
13494 wxPyEndAllowThreads(__tstate);
13495 if (PyErr_Occurred()) SWIG_fail;
13496 }
13497 {
13498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13499 }
13500 {
13501 if (temp2)
13502 delete arg2;
13503 }
13504 return resultobj;
13505 fail:
13506 {
13507 if (temp2)
13508 delete arg2;
13509 }
13510 return NULL;
13511 }
13512
13513
13514 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13515 PyObject *resultobj;
13516 wxSound *arg1 = (wxSound *) 0 ;
13517 PyObject *arg2 = (PyObject *) 0 ;
13518 bool result;
13519 PyObject * obj0 = 0 ;
13520 PyObject * obj1 = 0 ;
13521 char *kwnames[] = {
13522 (char *) "self",(char *) "data", NULL
13523 };
13524
13525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13527 if (SWIG_arg_fail(1)) SWIG_fail;
13528 arg2 = obj1;
13529 {
13530 PyThreadState* __tstate = wxPyBeginAllowThreads();
13531 result = (bool)wxSound_CreateFromData(arg1,arg2);
13532
13533 wxPyEndAllowThreads(__tstate);
13534 if (PyErr_Occurred()) SWIG_fail;
13535 }
13536 {
13537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13538 }
13539 return resultobj;
13540 fail:
13541 return NULL;
13542 }
13543
13544
13545 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13546 PyObject *resultobj;
13547 wxSound *arg1 = (wxSound *) 0 ;
13548 bool result;
13549 PyObject * obj0 = 0 ;
13550 char *kwnames[] = {
13551 (char *) "self", NULL
13552 };
13553
13554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13556 if (SWIG_arg_fail(1)) SWIG_fail;
13557 {
13558 PyThreadState* __tstate = wxPyBeginAllowThreads();
13559 result = (bool)(arg1)->IsOk();
13560
13561 wxPyEndAllowThreads(__tstate);
13562 if (PyErr_Occurred()) SWIG_fail;
13563 }
13564 {
13565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13566 }
13567 return resultobj;
13568 fail:
13569 return NULL;
13570 }
13571
13572
13573 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13574 PyObject *resultobj;
13575 wxSound *arg1 = (wxSound *) 0 ;
13576 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13577 bool result;
13578 PyObject * obj0 = 0 ;
13579 PyObject * obj1 = 0 ;
13580 char *kwnames[] = {
13581 (char *) "self",(char *) "flags", NULL
13582 };
13583
13584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13586 if (SWIG_arg_fail(1)) SWIG_fail;
13587 if (obj1) {
13588 {
13589 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13590 if (SWIG_arg_fail(2)) SWIG_fail;
13591 }
13592 }
13593 {
13594 if (!wxPyCheckForApp()) SWIG_fail;
13595 PyThreadState* __tstate = wxPyBeginAllowThreads();
13596 result = (bool)((wxSound const *)arg1)->Play(arg2);
13597
13598 wxPyEndAllowThreads(__tstate);
13599 if (PyErr_Occurred()) SWIG_fail;
13600 }
13601 {
13602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13603 }
13604 return resultobj;
13605 fail:
13606 return NULL;
13607 }
13608
13609
13610 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13611 PyObject *resultobj;
13612 wxString *arg1 = 0 ;
13613 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13614 bool result;
13615 bool temp1 = false ;
13616 PyObject * obj0 = 0 ;
13617 PyObject * obj1 = 0 ;
13618 char *kwnames[] = {
13619 (char *) "filename",(char *) "flags", NULL
13620 };
13621
13622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13623 {
13624 arg1 = wxString_in_helper(obj0);
13625 if (arg1 == NULL) SWIG_fail;
13626 temp1 = true;
13627 }
13628 if (obj1) {
13629 {
13630 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13631 if (SWIG_arg_fail(2)) SWIG_fail;
13632 }
13633 }
13634 {
13635 if (!wxPyCheckForApp()) SWIG_fail;
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13638
13639 wxPyEndAllowThreads(__tstate);
13640 if (PyErr_Occurred()) SWIG_fail;
13641 }
13642 {
13643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13644 }
13645 {
13646 if (temp1)
13647 delete arg1;
13648 }
13649 return resultobj;
13650 fail:
13651 {
13652 if (temp1)
13653 delete arg1;
13654 }
13655 return NULL;
13656 }
13657
13658
13659 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13660 PyObject *resultobj;
13661 char *kwnames[] = {
13662 NULL
13663 };
13664
13665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13666 {
13667 if (!wxPyCheckForApp()) SWIG_fail;
13668 PyThreadState* __tstate = wxPyBeginAllowThreads();
13669 wxSound::Stop();
13670
13671 wxPyEndAllowThreads(__tstate);
13672 if (PyErr_Occurred()) SWIG_fail;
13673 }
13674 Py_INCREF(Py_None); resultobj = Py_None;
13675 return resultobj;
13676 fail:
13677 return NULL;
13678 }
13679
13680
13681 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13682 PyObject *obj;
13683 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13684 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13685 Py_INCREF(obj);
13686 return Py_BuildValue((char *)"");
13687 }
13688 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13689 PyObject *resultobj;
13690 wxString *arg1 = 0 ;
13691 wxString *arg2 = 0 ;
13692 wxString *arg3 = 0 ;
13693 wxString *arg4 = 0 ;
13694 wxFileTypeInfo *result;
13695 bool temp1 = false ;
13696 bool temp2 = false ;
13697 bool temp3 = false ;
13698 bool temp4 = false ;
13699 PyObject * obj0 = 0 ;
13700 PyObject * obj1 = 0 ;
13701 PyObject * obj2 = 0 ;
13702 PyObject * obj3 = 0 ;
13703 char *kwnames[] = {
13704 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13705 };
13706
13707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13708 {
13709 arg1 = wxString_in_helper(obj0);
13710 if (arg1 == NULL) SWIG_fail;
13711 temp1 = true;
13712 }
13713 {
13714 arg2 = wxString_in_helper(obj1);
13715 if (arg2 == NULL) SWIG_fail;
13716 temp2 = true;
13717 }
13718 {
13719 arg3 = wxString_in_helper(obj2);
13720 if (arg3 == NULL) SWIG_fail;
13721 temp3 = true;
13722 }
13723 {
13724 arg4 = wxString_in_helper(obj3);
13725 if (arg4 == NULL) SWIG_fail;
13726 temp4 = true;
13727 }
13728 {
13729 PyThreadState* __tstate = wxPyBeginAllowThreads();
13730 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13731
13732 wxPyEndAllowThreads(__tstate);
13733 if (PyErr_Occurred()) SWIG_fail;
13734 }
13735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13736 {
13737 if (temp1)
13738 delete arg1;
13739 }
13740 {
13741 if (temp2)
13742 delete arg2;
13743 }
13744 {
13745 if (temp3)
13746 delete arg3;
13747 }
13748 {
13749 if (temp4)
13750 delete arg4;
13751 }
13752 return resultobj;
13753 fail:
13754 {
13755 if (temp1)
13756 delete arg1;
13757 }
13758 {
13759 if (temp2)
13760 delete arg2;
13761 }
13762 {
13763 if (temp3)
13764 delete arg3;
13765 }
13766 {
13767 if (temp4)
13768 delete arg4;
13769 }
13770 return NULL;
13771 }
13772
13773
13774 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13775 PyObject *resultobj;
13776 wxArrayString *arg1 = 0 ;
13777 wxFileTypeInfo *result;
13778 bool temp1 = false ;
13779 PyObject * obj0 = 0 ;
13780 char *kwnames[] = {
13781 (char *) "sArray", NULL
13782 };
13783
13784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13785 {
13786 if (! PySequence_Check(obj0)) {
13787 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13788 SWIG_fail;
13789 }
13790 arg1 = new wxArrayString;
13791 temp1 = true;
13792 int i, len=PySequence_Length(obj0);
13793 for (i=0; i<len; i++) {
13794 PyObject* item = PySequence_GetItem(obj0, i);
13795 #if wxUSE_UNICODE
13796 PyObject* str = PyObject_Unicode(item);
13797 #else
13798 PyObject* str = PyObject_Str(item);
13799 #endif
13800 if (PyErr_Occurred()) SWIG_fail;
13801 arg1->Add(Py2wxString(str));
13802 Py_DECREF(item);
13803 Py_DECREF(str);
13804 }
13805 }
13806 {
13807 PyThreadState* __tstate = wxPyBeginAllowThreads();
13808 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13809
13810 wxPyEndAllowThreads(__tstate);
13811 if (PyErr_Occurred()) SWIG_fail;
13812 }
13813 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13814 {
13815 if (temp1) delete arg1;
13816 }
13817 return resultobj;
13818 fail:
13819 {
13820 if (temp1) delete arg1;
13821 }
13822 return NULL;
13823 }
13824
13825
13826 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13827 PyObject *resultobj;
13828 wxFileTypeInfo *result;
13829 char *kwnames[] = {
13830 NULL
13831 };
13832
13833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13834 {
13835 PyThreadState* __tstate = wxPyBeginAllowThreads();
13836 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13837
13838 wxPyEndAllowThreads(__tstate);
13839 if (PyErr_Occurred()) SWIG_fail;
13840 }
13841 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13842 return resultobj;
13843 fail:
13844 return NULL;
13845 }
13846
13847
13848 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13849 PyObject *resultobj;
13850 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13851 bool result;
13852 PyObject * obj0 = 0 ;
13853 char *kwnames[] = {
13854 (char *) "self", NULL
13855 };
13856
13857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13859 if (SWIG_arg_fail(1)) SWIG_fail;
13860 {
13861 PyThreadState* __tstate = wxPyBeginAllowThreads();
13862 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13863
13864 wxPyEndAllowThreads(__tstate);
13865 if (PyErr_Occurred()) SWIG_fail;
13866 }
13867 {
13868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13869 }
13870 return resultobj;
13871 fail:
13872 return NULL;
13873 }
13874
13875
13876 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13877 PyObject *resultobj;
13878 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13879 wxString *arg2 = 0 ;
13880 int arg3 = (int) 0 ;
13881 bool temp2 = false ;
13882 PyObject * obj0 = 0 ;
13883 PyObject * obj1 = 0 ;
13884 PyObject * obj2 = 0 ;
13885 char *kwnames[] = {
13886 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13887 };
13888
13889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13891 if (SWIG_arg_fail(1)) SWIG_fail;
13892 {
13893 arg2 = wxString_in_helper(obj1);
13894 if (arg2 == NULL) SWIG_fail;
13895 temp2 = true;
13896 }
13897 if (obj2) {
13898 {
13899 arg3 = (int)(SWIG_As_int(obj2));
13900 if (SWIG_arg_fail(3)) SWIG_fail;
13901 }
13902 }
13903 {
13904 PyThreadState* __tstate = wxPyBeginAllowThreads();
13905 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13906
13907 wxPyEndAllowThreads(__tstate);
13908 if (PyErr_Occurred()) SWIG_fail;
13909 }
13910 Py_INCREF(Py_None); resultobj = Py_None;
13911 {
13912 if (temp2)
13913 delete arg2;
13914 }
13915 return resultobj;
13916 fail:
13917 {
13918 if (temp2)
13919 delete arg2;
13920 }
13921 return NULL;
13922 }
13923
13924
13925 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13926 PyObject *resultobj;
13927 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13928 wxString *arg2 = 0 ;
13929 bool temp2 = false ;
13930 PyObject * obj0 = 0 ;
13931 PyObject * obj1 = 0 ;
13932 char *kwnames[] = {
13933 (char *) "self",(char *) "shortDesc", NULL
13934 };
13935
13936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
13941 if (arg2 == NULL) SWIG_fail;
13942 temp2 = true;
13943 }
13944 {
13945 PyThreadState* __tstate = wxPyBeginAllowThreads();
13946 (arg1)->SetShortDesc((wxString const &)*arg2);
13947
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 Py_INCREF(Py_None); resultobj = Py_None;
13952 {
13953 if (temp2)
13954 delete arg2;
13955 }
13956 return resultobj;
13957 fail:
13958 {
13959 if (temp2)
13960 delete arg2;
13961 }
13962 return NULL;
13963 }
13964
13965
13966 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13967 PyObject *resultobj;
13968 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13969 wxString *result;
13970 PyObject * obj0 = 0 ;
13971 char *kwnames[] = {
13972 (char *) "self", NULL
13973 };
13974
13975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13977 if (SWIG_arg_fail(1)) SWIG_fail;
13978 {
13979 PyThreadState* __tstate = wxPyBeginAllowThreads();
13980 {
13981 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13982 result = (wxString *) &_result_ref;
13983 }
13984
13985 wxPyEndAllowThreads(__tstate);
13986 if (PyErr_Occurred()) SWIG_fail;
13987 }
13988 {
13989 #if wxUSE_UNICODE
13990 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13991 #else
13992 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13993 #endif
13994 }
13995 return resultobj;
13996 fail:
13997 return NULL;
13998 }
13999
14000
14001 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14002 PyObject *resultobj;
14003 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14004 wxString *result;
14005 PyObject * obj0 = 0 ;
14006 char *kwnames[] = {
14007 (char *) "self", NULL
14008 };
14009
14010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14012 if (SWIG_arg_fail(1)) SWIG_fail;
14013 {
14014 PyThreadState* __tstate = wxPyBeginAllowThreads();
14015 {
14016 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14017 result = (wxString *) &_result_ref;
14018 }
14019
14020 wxPyEndAllowThreads(__tstate);
14021 if (PyErr_Occurred()) SWIG_fail;
14022 }
14023 {
14024 #if wxUSE_UNICODE
14025 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14026 #else
14027 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14028 #endif
14029 }
14030 return resultobj;
14031 fail:
14032 return NULL;
14033 }
14034
14035
14036 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14037 PyObject *resultobj;
14038 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14039 wxString *result;
14040 PyObject * obj0 = 0 ;
14041 char *kwnames[] = {
14042 (char *) "self", NULL
14043 };
14044
14045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14047 if (SWIG_arg_fail(1)) SWIG_fail;
14048 {
14049 PyThreadState* __tstate = wxPyBeginAllowThreads();
14050 {
14051 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14052 result = (wxString *) &_result_ref;
14053 }
14054
14055 wxPyEndAllowThreads(__tstate);
14056 if (PyErr_Occurred()) SWIG_fail;
14057 }
14058 {
14059 #if wxUSE_UNICODE
14060 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14061 #else
14062 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14063 #endif
14064 }
14065 return resultobj;
14066 fail:
14067 return NULL;
14068 }
14069
14070
14071 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14072 PyObject *resultobj;
14073 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14074 wxString *result;
14075 PyObject * obj0 = 0 ;
14076 char *kwnames[] = {
14077 (char *) "self", NULL
14078 };
14079
14080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14082 if (SWIG_arg_fail(1)) SWIG_fail;
14083 {
14084 PyThreadState* __tstate = wxPyBeginAllowThreads();
14085 {
14086 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14087 result = (wxString *) &_result_ref;
14088 }
14089
14090 wxPyEndAllowThreads(__tstate);
14091 if (PyErr_Occurred()) SWIG_fail;
14092 }
14093 {
14094 #if wxUSE_UNICODE
14095 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14096 #else
14097 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14098 #endif
14099 }
14100 return resultobj;
14101 fail:
14102 return NULL;
14103 }
14104
14105
14106 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14107 PyObject *resultobj;
14108 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14109 wxString *result;
14110 PyObject * obj0 = 0 ;
14111 char *kwnames[] = {
14112 (char *) "self", NULL
14113 };
14114
14115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14117 if (SWIG_arg_fail(1)) SWIG_fail;
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 {
14121 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14122 result = (wxString *) &_result_ref;
14123 }
14124
14125 wxPyEndAllowThreads(__tstate);
14126 if (PyErr_Occurred()) SWIG_fail;
14127 }
14128 {
14129 #if wxUSE_UNICODE
14130 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14131 #else
14132 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14133 #endif
14134 }
14135 return resultobj;
14136 fail:
14137 return NULL;
14138 }
14139
14140
14141 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14142 PyObject *resultobj;
14143 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14144 wxArrayString *result;
14145 PyObject * obj0 = 0 ;
14146 char *kwnames[] = {
14147 (char *) "self", NULL
14148 };
14149
14150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14152 if (SWIG_arg_fail(1)) SWIG_fail;
14153 {
14154 PyThreadState* __tstate = wxPyBeginAllowThreads();
14155 {
14156 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14157 result = (wxArrayString *) &_result_ref;
14158 }
14159
14160 wxPyEndAllowThreads(__tstate);
14161 if (PyErr_Occurred()) SWIG_fail;
14162 }
14163 {
14164 resultobj = wxArrayString2PyList_helper(*result);
14165 }
14166 return resultobj;
14167 fail:
14168 return NULL;
14169 }
14170
14171
14172 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14173 PyObject *resultobj;
14174 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14175 int result;
14176 PyObject * obj0 = 0 ;
14177 char *kwnames[] = {
14178 (char *) "self", NULL
14179 };
14180
14181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14183 if (SWIG_arg_fail(1)) SWIG_fail;
14184 {
14185 PyThreadState* __tstate = wxPyBeginAllowThreads();
14186 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14187
14188 wxPyEndAllowThreads(__tstate);
14189 if (PyErr_Occurred()) SWIG_fail;
14190 }
14191 {
14192 resultobj = SWIG_From_int((int)(result));
14193 }
14194 return resultobj;
14195 fail:
14196 return NULL;
14197 }
14198
14199
14200 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14201 PyObject *resultobj;
14202 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14203 wxString *result;
14204 PyObject * obj0 = 0 ;
14205 char *kwnames[] = {
14206 (char *) "self", NULL
14207 };
14208
14209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14211 if (SWIG_arg_fail(1)) SWIG_fail;
14212 {
14213 PyThreadState* __tstate = wxPyBeginAllowThreads();
14214 {
14215 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14216 result = (wxString *) &_result_ref;
14217 }
14218
14219 wxPyEndAllowThreads(__tstate);
14220 if (PyErr_Occurred()) SWIG_fail;
14221 }
14222 {
14223 #if wxUSE_UNICODE
14224 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14225 #else
14226 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14227 #endif
14228 }
14229 return resultobj;
14230 fail:
14231 return NULL;
14232 }
14233
14234
14235 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14236 PyObject *resultobj;
14237 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14238 int result;
14239 PyObject * obj0 = 0 ;
14240 char *kwnames[] = {
14241 (char *) "self", NULL
14242 };
14243
14244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14246 if (SWIG_arg_fail(1)) SWIG_fail;
14247 {
14248 PyThreadState* __tstate = wxPyBeginAllowThreads();
14249 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14250
14251 wxPyEndAllowThreads(__tstate);
14252 if (PyErr_Occurred()) SWIG_fail;
14253 }
14254 {
14255 resultobj = SWIG_From_int((int)(result));
14256 }
14257 return resultobj;
14258 fail:
14259 return NULL;
14260 }
14261
14262
14263 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14264 PyObject *obj;
14265 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14266 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14267 Py_INCREF(obj);
14268 return Py_BuildValue((char *)"");
14269 }
14270 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14271 PyObject *resultobj;
14272 wxFileTypeInfo *arg1 = 0 ;
14273 wxFileType *result;
14274 PyObject * obj0 = 0 ;
14275 char *kwnames[] = {
14276 (char *) "ftInfo", NULL
14277 };
14278
14279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14280 {
14281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14282 if (SWIG_arg_fail(1)) SWIG_fail;
14283 if (arg1 == NULL) {
14284 SWIG_null_ref("wxFileTypeInfo");
14285 }
14286 if (SWIG_arg_fail(1)) SWIG_fail;
14287 }
14288 {
14289 PyThreadState* __tstate = wxPyBeginAllowThreads();
14290 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14291
14292 wxPyEndAllowThreads(__tstate);
14293 if (PyErr_Occurred()) SWIG_fail;
14294 }
14295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14296 return resultobj;
14297 fail:
14298 return NULL;
14299 }
14300
14301
14302 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14303 PyObject *resultobj;
14304 wxFileType *arg1 = (wxFileType *) 0 ;
14305 PyObject * obj0 = 0 ;
14306 char *kwnames[] = {
14307 (char *) "self", NULL
14308 };
14309
14310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14312 if (SWIG_arg_fail(1)) SWIG_fail;
14313 {
14314 PyThreadState* __tstate = wxPyBeginAllowThreads();
14315 delete arg1;
14316
14317 wxPyEndAllowThreads(__tstate);
14318 if (PyErr_Occurred()) SWIG_fail;
14319 }
14320 Py_INCREF(Py_None); resultobj = Py_None;
14321 return resultobj;
14322 fail:
14323 return NULL;
14324 }
14325
14326
14327 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14328 PyObject *resultobj;
14329 wxFileType *arg1 = (wxFileType *) 0 ;
14330 PyObject *result;
14331 PyObject * obj0 = 0 ;
14332 char *kwnames[] = {
14333 (char *) "self", NULL
14334 };
14335
14336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14338 if (SWIG_arg_fail(1)) SWIG_fail;
14339 {
14340 PyThreadState* __tstate = wxPyBeginAllowThreads();
14341 result = (PyObject *)wxFileType_GetMimeType(arg1);
14342
14343 wxPyEndAllowThreads(__tstate);
14344 if (PyErr_Occurred()) SWIG_fail;
14345 }
14346 resultobj = result;
14347 return resultobj;
14348 fail:
14349 return NULL;
14350 }
14351
14352
14353 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14354 PyObject *resultobj;
14355 wxFileType *arg1 = (wxFileType *) 0 ;
14356 PyObject *result;
14357 PyObject * obj0 = 0 ;
14358 char *kwnames[] = {
14359 (char *) "self", NULL
14360 };
14361
14362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14364 if (SWIG_arg_fail(1)) SWIG_fail;
14365 {
14366 PyThreadState* __tstate = wxPyBeginAllowThreads();
14367 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14368
14369 wxPyEndAllowThreads(__tstate);
14370 if (PyErr_Occurred()) SWIG_fail;
14371 }
14372 resultobj = result;
14373 return resultobj;
14374 fail:
14375 return NULL;
14376 }
14377
14378
14379 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14380 PyObject *resultobj;
14381 wxFileType *arg1 = (wxFileType *) 0 ;
14382 PyObject *result;
14383 PyObject * obj0 = 0 ;
14384 char *kwnames[] = {
14385 (char *) "self", NULL
14386 };
14387
14388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14390 if (SWIG_arg_fail(1)) SWIG_fail;
14391 {
14392 PyThreadState* __tstate = wxPyBeginAllowThreads();
14393 result = (PyObject *)wxFileType_GetExtensions(arg1);
14394
14395 wxPyEndAllowThreads(__tstate);
14396 if (PyErr_Occurred()) SWIG_fail;
14397 }
14398 resultobj = result;
14399 return resultobj;
14400 fail:
14401 return NULL;
14402 }
14403
14404
14405 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14406 PyObject *resultobj;
14407 wxFileType *arg1 = (wxFileType *) 0 ;
14408 wxIcon *result;
14409 PyObject * obj0 = 0 ;
14410 char *kwnames[] = {
14411 (char *) "self", NULL
14412 };
14413
14414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14416 if (SWIG_arg_fail(1)) SWIG_fail;
14417 {
14418 PyThreadState* __tstate = wxPyBeginAllowThreads();
14419 result = (wxIcon *)wxFileType_GetIcon(arg1);
14420
14421 wxPyEndAllowThreads(__tstate);
14422 if (PyErr_Occurred()) SWIG_fail;
14423 }
14424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14425 return resultobj;
14426 fail:
14427 return NULL;
14428 }
14429
14430
14431 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14432 PyObject *resultobj;
14433 wxFileType *arg1 = (wxFileType *) 0 ;
14434 PyObject *result;
14435 PyObject * obj0 = 0 ;
14436 char *kwnames[] = {
14437 (char *) "self", NULL
14438 };
14439
14440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14442 if (SWIG_arg_fail(1)) SWIG_fail;
14443 {
14444 PyThreadState* __tstate = wxPyBeginAllowThreads();
14445 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14446
14447 wxPyEndAllowThreads(__tstate);
14448 if (PyErr_Occurred()) SWIG_fail;
14449 }
14450 resultobj = result;
14451 return resultobj;
14452 fail:
14453 return NULL;
14454 }
14455
14456
14457 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14458 PyObject *resultobj;
14459 wxFileType *arg1 = (wxFileType *) 0 ;
14460 PyObject *result;
14461 PyObject * obj0 = 0 ;
14462 char *kwnames[] = {
14463 (char *) "self", NULL
14464 };
14465
14466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14468 if (SWIG_arg_fail(1)) SWIG_fail;
14469 {
14470 PyThreadState* __tstate = wxPyBeginAllowThreads();
14471 result = (PyObject *)wxFileType_GetDescription(arg1);
14472
14473 wxPyEndAllowThreads(__tstate);
14474 if (PyErr_Occurred()) SWIG_fail;
14475 }
14476 resultobj = result;
14477 return resultobj;
14478 fail:
14479 return NULL;
14480 }
14481
14482
14483 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14484 PyObject *resultobj;
14485 wxFileType *arg1 = (wxFileType *) 0 ;
14486 wxString *arg2 = 0 ;
14487 wxString const &arg3_defvalue = wxPyEmptyString ;
14488 wxString *arg3 = (wxString *) &arg3_defvalue ;
14489 PyObject *result;
14490 bool temp2 = false ;
14491 bool temp3 = false ;
14492 PyObject * obj0 = 0 ;
14493 PyObject * obj1 = 0 ;
14494 PyObject * obj2 = 0 ;
14495 char *kwnames[] = {
14496 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14497 };
14498
14499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14501 if (SWIG_arg_fail(1)) SWIG_fail;
14502 {
14503 arg2 = wxString_in_helper(obj1);
14504 if (arg2 == NULL) SWIG_fail;
14505 temp2 = true;
14506 }
14507 if (obj2) {
14508 {
14509 arg3 = wxString_in_helper(obj2);
14510 if (arg3 == NULL) SWIG_fail;
14511 temp3 = true;
14512 }
14513 }
14514 {
14515 PyThreadState* __tstate = wxPyBeginAllowThreads();
14516 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14517
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 resultobj = result;
14522 {
14523 if (temp2)
14524 delete arg2;
14525 }
14526 {
14527 if (temp3)
14528 delete arg3;
14529 }
14530 return resultobj;
14531 fail:
14532 {
14533 if (temp2)
14534 delete arg2;
14535 }
14536 {
14537 if (temp3)
14538 delete arg3;
14539 }
14540 return NULL;
14541 }
14542
14543
14544 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14545 PyObject *resultobj;
14546 wxFileType *arg1 = (wxFileType *) 0 ;
14547 wxString *arg2 = 0 ;
14548 wxString const &arg3_defvalue = wxPyEmptyString ;
14549 wxString *arg3 = (wxString *) &arg3_defvalue ;
14550 PyObject *result;
14551 bool temp2 = false ;
14552 bool temp3 = false ;
14553 PyObject * obj0 = 0 ;
14554 PyObject * obj1 = 0 ;
14555 PyObject * obj2 = 0 ;
14556 char *kwnames[] = {
14557 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14558 };
14559
14560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14562 if (SWIG_arg_fail(1)) SWIG_fail;
14563 {
14564 arg2 = wxString_in_helper(obj1);
14565 if (arg2 == NULL) SWIG_fail;
14566 temp2 = true;
14567 }
14568 if (obj2) {
14569 {
14570 arg3 = wxString_in_helper(obj2);
14571 if (arg3 == NULL) SWIG_fail;
14572 temp3 = true;
14573 }
14574 }
14575 {
14576 PyThreadState* __tstate = wxPyBeginAllowThreads();
14577 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14578
14579 wxPyEndAllowThreads(__tstate);
14580 if (PyErr_Occurred()) SWIG_fail;
14581 }
14582 resultobj = result;
14583 {
14584 if (temp2)
14585 delete arg2;
14586 }
14587 {
14588 if (temp3)
14589 delete arg3;
14590 }
14591 return resultobj;
14592 fail:
14593 {
14594 if (temp2)
14595 delete arg2;
14596 }
14597 {
14598 if (temp3)
14599 delete arg3;
14600 }
14601 return NULL;
14602 }
14603
14604
14605 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14606 PyObject *resultobj;
14607 wxFileType *arg1 = (wxFileType *) 0 ;
14608 wxString *arg2 = 0 ;
14609 wxString const &arg3_defvalue = wxPyEmptyString ;
14610 wxString *arg3 = (wxString *) &arg3_defvalue ;
14611 PyObject *result;
14612 bool temp2 = false ;
14613 bool temp3 = false ;
14614 PyObject * obj0 = 0 ;
14615 PyObject * obj1 = 0 ;
14616 PyObject * obj2 = 0 ;
14617 char *kwnames[] = {
14618 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14619 };
14620
14621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14623 if (SWIG_arg_fail(1)) SWIG_fail;
14624 {
14625 arg2 = wxString_in_helper(obj1);
14626 if (arg2 == NULL) SWIG_fail;
14627 temp2 = true;
14628 }
14629 if (obj2) {
14630 {
14631 arg3 = wxString_in_helper(obj2);
14632 if (arg3 == NULL) SWIG_fail;
14633 temp3 = true;
14634 }
14635 }
14636 {
14637 PyThreadState* __tstate = wxPyBeginAllowThreads();
14638 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14639
14640 wxPyEndAllowThreads(__tstate);
14641 if (PyErr_Occurred()) SWIG_fail;
14642 }
14643 resultobj = result;
14644 {
14645 if (temp2)
14646 delete arg2;
14647 }
14648 {
14649 if (temp3)
14650 delete arg3;
14651 }
14652 return resultobj;
14653 fail:
14654 {
14655 if (temp2)
14656 delete arg2;
14657 }
14658 {
14659 if (temp3)
14660 delete arg3;
14661 }
14662 return NULL;
14663 }
14664
14665
14666 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14667 PyObject *resultobj;
14668 wxFileType *arg1 = (wxFileType *) 0 ;
14669 wxString *arg2 = 0 ;
14670 wxString *arg3 = 0 ;
14671 bool arg4 = (bool) true ;
14672 bool result;
14673 bool temp2 = false ;
14674 bool temp3 = false ;
14675 PyObject * obj0 = 0 ;
14676 PyObject * obj1 = 0 ;
14677 PyObject * obj2 = 0 ;
14678 PyObject * obj3 = 0 ;
14679 char *kwnames[] = {
14680 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14681 };
14682
14683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14685 if (SWIG_arg_fail(1)) SWIG_fail;
14686 {
14687 arg2 = wxString_in_helper(obj1);
14688 if (arg2 == NULL) SWIG_fail;
14689 temp2 = true;
14690 }
14691 {
14692 arg3 = wxString_in_helper(obj2);
14693 if (arg3 == NULL) SWIG_fail;
14694 temp3 = true;
14695 }
14696 if (obj3) {
14697 {
14698 arg4 = (bool)(SWIG_As_bool(obj3));
14699 if (SWIG_arg_fail(4)) SWIG_fail;
14700 }
14701 }
14702 {
14703 PyThreadState* __tstate = wxPyBeginAllowThreads();
14704 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14705
14706 wxPyEndAllowThreads(__tstate);
14707 if (PyErr_Occurred()) SWIG_fail;
14708 }
14709 {
14710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14711 }
14712 {
14713 if (temp2)
14714 delete arg2;
14715 }
14716 {
14717 if (temp3)
14718 delete arg3;
14719 }
14720 return resultobj;
14721 fail:
14722 {
14723 if (temp2)
14724 delete arg2;
14725 }
14726 {
14727 if (temp3)
14728 delete arg3;
14729 }
14730 return NULL;
14731 }
14732
14733
14734 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14735 PyObject *resultobj;
14736 wxFileType *arg1 = (wxFileType *) 0 ;
14737 wxString const &arg2_defvalue = wxPyEmptyString ;
14738 wxString *arg2 = (wxString *) &arg2_defvalue ;
14739 int arg3 = (int) 0 ;
14740 bool result;
14741 bool temp2 = false ;
14742 PyObject * obj0 = 0 ;
14743 PyObject * obj1 = 0 ;
14744 PyObject * obj2 = 0 ;
14745 char *kwnames[] = {
14746 (char *) "self",(char *) "cmd",(char *) "index", NULL
14747 };
14748
14749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14751 if (SWIG_arg_fail(1)) SWIG_fail;
14752 if (obj1) {
14753 {
14754 arg2 = wxString_in_helper(obj1);
14755 if (arg2 == NULL) SWIG_fail;
14756 temp2 = true;
14757 }
14758 }
14759 if (obj2) {
14760 {
14761 arg3 = (int)(SWIG_As_int(obj2));
14762 if (SWIG_arg_fail(3)) SWIG_fail;
14763 }
14764 }
14765 {
14766 PyThreadState* __tstate = wxPyBeginAllowThreads();
14767 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14768
14769 wxPyEndAllowThreads(__tstate);
14770 if (PyErr_Occurred()) SWIG_fail;
14771 }
14772 {
14773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14774 }
14775 {
14776 if (temp2)
14777 delete arg2;
14778 }
14779 return resultobj;
14780 fail:
14781 {
14782 if (temp2)
14783 delete arg2;
14784 }
14785 return NULL;
14786 }
14787
14788
14789 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14790 PyObject *resultobj;
14791 wxFileType *arg1 = (wxFileType *) 0 ;
14792 bool result;
14793 PyObject * obj0 = 0 ;
14794 char *kwnames[] = {
14795 (char *) "self", NULL
14796 };
14797
14798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14800 if (SWIG_arg_fail(1)) SWIG_fail;
14801 {
14802 PyThreadState* __tstate = wxPyBeginAllowThreads();
14803 result = (bool)(arg1)->Unassociate();
14804
14805 wxPyEndAllowThreads(__tstate);
14806 if (PyErr_Occurred()) SWIG_fail;
14807 }
14808 {
14809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14810 }
14811 return resultobj;
14812 fail:
14813 return NULL;
14814 }
14815
14816
14817 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14818 PyObject *resultobj;
14819 wxString *arg1 = 0 ;
14820 wxString *arg2 = 0 ;
14821 wxString const &arg3_defvalue = wxPyEmptyString ;
14822 wxString *arg3 = (wxString *) &arg3_defvalue ;
14823 wxString result;
14824 bool temp1 = false ;
14825 bool temp2 = false ;
14826 bool temp3 = false ;
14827 PyObject * obj0 = 0 ;
14828 PyObject * obj1 = 0 ;
14829 PyObject * obj2 = 0 ;
14830 char *kwnames[] = {
14831 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14832 };
14833
14834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14835 {
14836 arg1 = wxString_in_helper(obj0);
14837 if (arg1 == NULL) SWIG_fail;
14838 temp1 = true;
14839 }
14840 {
14841 arg2 = wxString_in_helper(obj1);
14842 if (arg2 == NULL) SWIG_fail;
14843 temp2 = true;
14844 }
14845 if (obj2) {
14846 {
14847 arg3 = wxString_in_helper(obj2);
14848 if (arg3 == NULL) SWIG_fail;
14849 temp3 = true;
14850 }
14851 }
14852 {
14853 PyThreadState* __tstate = wxPyBeginAllowThreads();
14854 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14855
14856 wxPyEndAllowThreads(__tstate);
14857 if (PyErr_Occurred()) SWIG_fail;
14858 }
14859 {
14860 #if wxUSE_UNICODE
14861 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14862 #else
14863 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14864 #endif
14865 }
14866 {
14867 if (temp1)
14868 delete arg1;
14869 }
14870 {
14871 if (temp2)
14872 delete arg2;
14873 }
14874 {
14875 if (temp3)
14876 delete arg3;
14877 }
14878 return resultobj;
14879 fail:
14880 {
14881 if (temp1)
14882 delete arg1;
14883 }
14884 {
14885 if (temp2)
14886 delete arg2;
14887 }
14888 {
14889 if (temp3)
14890 delete arg3;
14891 }
14892 return NULL;
14893 }
14894
14895
14896 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14897 PyObject *obj;
14898 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14899 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14900 Py_INCREF(obj);
14901 return Py_BuildValue((char *)"");
14902 }
14903 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14904 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14905 return 1;
14906 }
14907
14908
14909 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14910 PyObject *pyobj;
14911
14912 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14913 return pyobj;
14914 }
14915
14916
14917 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14918 PyObject *resultobj;
14919 wxString *arg1 = 0 ;
14920 wxString *arg2 = 0 ;
14921 bool result;
14922 bool temp1 = false ;
14923 bool temp2 = false ;
14924 PyObject * obj0 = 0 ;
14925 PyObject * obj1 = 0 ;
14926 char *kwnames[] = {
14927 (char *) "mimeType",(char *) "wildcard", NULL
14928 };
14929
14930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14931 {
14932 arg1 = wxString_in_helper(obj0);
14933 if (arg1 == NULL) SWIG_fail;
14934 temp1 = true;
14935 }
14936 {
14937 arg2 = wxString_in_helper(obj1);
14938 if (arg2 == NULL) SWIG_fail;
14939 temp2 = true;
14940 }
14941 {
14942 PyThreadState* __tstate = wxPyBeginAllowThreads();
14943 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14944
14945 wxPyEndAllowThreads(__tstate);
14946 if (PyErr_Occurred()) SWIG_fail;
14947 }
14948 {
14949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14950 }
14951 {
14952 if (temp1)
14953 delete arg1;
14954 }
14955 {
14956 if (temp2)
14957 delete arg2;
14958 }
14959 return resultobj;
14960 fail:
14961 {
14962 if (temp1)
14963 delete arg1;
14964 }
14965 {
14966 if (temp2)
14967 delete arg2;
14968 }
14969 return NULL;
14970 }
14971
14972
14973 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14974 PyObject *resultobj;
14975 wxMimeTypesManager *result;
14976 char *kwnames[] = {
14977 NULL
14978 };
14979
14980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14981 {
14982 PyThreadState* __tstate = wxPyBeginAllowThreads();
14983 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14984
14985 wxPyEndAllowThreads(__tstate);
14986 if (PyErr_Occurred()) SWIG_fail;
14987 }
14988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14989 return resultobj;
14990 fail:
14991 return NULL;
14992 }
14993
14994
14995 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14996 PyObject *resultobj;
14997 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14998 int arg2 = (int) wxMAILCAP_ALL ;
14999 wxString const &arg3_defvalue = wxPyEmptyString ;
15000 wxString *arg3 = (wxString *) &arg3_defvalue ;
15001 bool temp3 = false ;
15002 PyObject * obj0 = 0 ;
15003 PyObject * obj1 = 0 ;
15004 PyObject * obj2 = 0 ;
15005 char *kwnames[] = {
15006 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15007 };
15008
15009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15011 if (SWIG_arg_fail(1)) SWIG_fail;
15012 if (obj1) {
15013 {
15014 arg2 = (int)(SWIG_As_int(obj1));
15015 if (SWIG_arg_fail(2)) SWIG_fail;
15016 }
15017 }
15018 if (obj2) {
15019 {
15020 arg3 = wxString_in_helper(obj2);
15021 if (arg3 == NULL) SWIG_fail;
15022 temp3 = true;
15023 }
15024 }
15025 {
15026 PyThreadState* __tstate = wxPyBeginAllowThreads();
15027 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15028
15029 wxPyEndAllowThreads(__tstate);
15030 if (PyErr_Occurred()) SWIG_fail;
15031 }
15032 Py_INCREF(Py_None); resultobj = Py_None;
15033 {
15034 if (temp3)
15035 delete arg3;
15036 }
15037 return resultobj;
15038 fail:
15039 {
15040 if (temp3)
15041 delete arg3;
15042 }
15043 return NULL;
15044 }
15045
15046
15047 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15048 PyObject *resultobj;
15049 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15050 PyObject * obj0 = 0 ;
15051 char *kwnames[] = {
15052 (char *) "self", NULL
15053 };
15054
15055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15057 if (SWIG_arg_fail(1)) SWIG_fail;
15058 {
15059 PyThreadState* __tstate = wxPyBeginAllowThreads();
15060 (arg1)->ClearData();
15061
15062 wxPyEndAllowThreads(__tstate);
15063 if (PyErr_Occurred()) SWIG_fail;
15064 }
15065 Py_INCREF(Py_None); resultobj = Py_None;
15066 return resultobj;
15067 fail:
15068 return NULL;
15069 }
15070
15071
15072 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15073 PyObject *resultobj;
15074 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15075 wxString *arg2 = 0 ;
15076 wxFileType *result;
15077 bool temp2 = false ;
15078 PyObject * obj0 = 0 ;
15079 PyObject * obj1 = 0 ;
15080 char *kwnames[] = {
15081 (char *) "self",(char *) "ext", NULL
15082 };
15083
15084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15086 if (SWIG_arg_fail(1)) SWIG_fail;
15087 {
15088 arg2 = wxString_in_helper(obj1);
15089 if (arg2 == NULL) SWIG_fail;
15090 temp2 = true;
15091 }
15092 {
15093 PyThreadState* __tstate = wxPyBeginAllowThreads();
15094 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15095
15096 wxPyEndAllowThreads(__tstate);
15097 if (PyErr_Occurred()) SWIG_fail;
15098 }
15099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15100 {
15101 if (temp2)
15102 delete arg2;
15103 }
15104 return resultobj;
15105 fail:
15106 {
15107 if (temp2)
15108 delete arg2;
15109 }
15110 return NULL;
15111 }
15112
15113
15114 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15115 PyObject *resultobj;
15116 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15117 wxString *arg2 = 0 ;
15118 wxFileType *result;
15119 bool temp2 = false ;
15120 PyObject * obj0 = 0 ;
15121 PyObject * obj1 = 0 ;
15122 char *kwnames[] = {
15123 (char *) "self",(char *) "mimeType", NULL
15124 };
15125
15126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15128 if (SWIG_arg_fail(1)) SWIG_fail;
15129 {
15130 arg2 = wxString_in_helper(obj1);
15131 if (arg2 == NULL) SWIG_fail;
15132 temp2 = true;
15133 }
15134 {
15135 PyThreadState* __tstate = wxPyBeginAllowThreads();
15136 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15137
15138 wxPyEndAllowThreads(__tstate);
15139 if (PyErr_Occurred()) SWIG_fail;
15140 }
15141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15142 {
15143 if (temp2)
15144 delete arg2;
15145 }
15146 return resultobj;
15147 fail:
15148 {
15149 if (temp2)
15150 delete arg2;
15151 }
15152 return NULL;
15153 }
15154
15155
15156 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15157 PyObject *resultobj;
15158 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15159 wxString *arg2 = 0 ;
15160 bool arg3 = (bool) false ;
15161 bool result;
15162 bool temp2 = false ;
15163 PyObject * obj0 = 0 ;
15164 PyObject * obj1 = 0 ;
15165 PyObject * obj2 = 0 ;
15166 char *kwnames[] = {
15167 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15168 };
15169
15170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15172 if (SWIG_arg_fail(1)) SWIG_fail;
15173 {
15174 arg2 = wxString_in_helper(obj1);
15175 if (arg2 == NULL) SWIG_fail;
15176 temp2 = true;
15177 }
15178 if (obj2) {
15179 {
15180 arg3 = (bool)(SWIG_As_bool(obj2));
15181 if (SWIG_arg_fail(3)) SWIG_fail;
15182 }
15183 }
15184 {
15185 PyThreadState* __tstate = wxPyBeginAllowThreads();
15186 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15187
15188 wxPyEndAllowThreads(__tstate);
15189 if (PyErr_Occurred()) SWIG_fail;
15190 }
15191 {
15192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15193 }
15194 {
15195 if (temp2)
15196 delete arg2;
15197 }
15198 return resultobj;
15199 fail:
15200 {
15201 if (temp2)
15202 delete arg2;
15203 }
15204 return NULL;
15205 }
15206
15207
15208 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15209 PyObject *resultobj;
15210 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15211 wxString *arg2 = 0 ;
15212 bool result;
15213 bool temp2 = false ;
15214 PyObject * obj0 = 0 ;
15215 PyObject * obj1 = 0 ;
15216 char *kwnames[] = {
15217 (char *) "self",(char *) "filename", NULL
15218 };
15219
15220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15222 if (SWIG_arg_fail(1)) SWIG_fail;
15223 {
15224 arg2 = wxString_in_helper(obj1);
15225 if (arg2 == NULL) SWIG_fail;
15226 temp2 = true;
15227 }
15228 {
15229 PyThreadState* __tstate = wxPyBeginAllowThreads();
15230 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15231
15232 wxPyEndAllowThreads(__tstate);
15233 if (PyErr_Occurred()) SWIG_fail;
15234 }
15235 {
15236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15237 }
15238 {
15239 if (temp2)
15240 delete arg2;
15241 }
15242 return resultobj;
15243 fail:
15244 {
15245 if (temp2)
15246 delete arg2;
15247 }
15248 return NULL;
15249 }
15250
15251
15252 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15253 PyObject *resultobj;
15254 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15255 PyObject *result;
15256 PyObject * obj0 = 0 ;
15257 char *kwnames[] = {
15258 (char *) "self", NULL
15259 };
15260
15261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15263 if (SWIG_arg_fail(1)) SWIG_fail;
15264 {
15265 PyThreadState* __tstate = wxPyBeginAllowThreads();
15266 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15267
15268 wxPyEndAllowThreads(__tstate);
15269 if (PyErr_Occurred()) SWIG_fail;
15270 }
15271 resultobj = result;
15272 return resultobj;
15273 fail:
15274 return NULL;
15275 }
15276
15277
15278 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15279 PyObject *resultobj;
15280 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15281 wxFileTypeInfo *arg2 = 0 ;
15282 PyObject * obj0 = 0 ;
15283 PyObject * obj1 = 0 ;
15284 char *kwnames[] = {
15285 (char *) "self",(char *) "ft", NULL
15286 };
15287
15288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15290 if (SWIG_arg_fail(1)) SWIG_fail;
15291 {
15292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15293 if (SWIG_arg_fail(2)) SWIG_fail;
15294 if (arg2 == NULL) {
15295 SWIG_null_ref("wxFileTypeInfo");
15296 }
15297 if (SWIG_arg_fail(2)) SWIG_fail;
15298 }
15299 {
15300 PyThreadState* __tstate = wxPyBeginAllowThreads();
15301 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15302
15303 wxPyEndAllowThreads(__tstate);
15304 if (PyErr_Occurred()) SWIG_fail;
15305 }
15306 Py_INCREF(Py_None); resultobj = Py_None;
15307 return resultobj;
15308 fail:
15309 return NULL;
15310 }
15311
15312
15313 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15314 PyObject *resultobj;
15315 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15316 wxFileTypeInfo *arg2 = 0 ;
15317 wxFileType *result;
15318 PyObject * obj0 = 0 ;
15319 PyObject * obj1 = 0 ;
15320 char *kwnames[] = {
15321 (char *) "self",(char *) "ftInfo", NULL
15322 };
15323
15324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15326 if (SWIG_arg_fail(1)) SWIG_fail;
15327 {
15328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15329 if (SWIG_arg_fail(2)) SWIG_fail;
15330 if (arg2 == NULL) {
15331 SWIG_null_ref("wxFileTypeInfo");
15332 }
15333 if (SWIG_arg_fail(2)) SWIG_fail;
15334 }
15335 {
15336 PyThreadState* __tstate = wxPyBeginAllowThreads();
15337 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15338
15339 wxPyEndAllowThreads(__tstate);
15340 if (PyErr_Occurred()) SWIG_fail;
15341 }
15342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15343 return resultobj;
15344 fail:
15345 return NULL;
15346 }
15347
15348
15349 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15350 PyObject *resultobj;
15351 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15352 wxFileType *arg2 = (wxFileType *) 0 ;
15353 bool result;
15354 PyObject * obj0 = 0 ;
15355 PyObject * obj1 = 0 ;
15356 char *kwnames[] = {
15357 (char *) "self",(char *) "ft", NULL
15358 };
15359
15360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15362 if (SWIG_arg_fail(1)) SWIG_fail;
15363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15364 if (SWIG_arg_fail(2)) SWIG_fail;
15365 {
15366 PyThreadState* __tstate = wxPyBeginAllowThreads();
15367 result = (bool)(arg1)->Unassociate(arg2);
15368
15369 wxPyEndAllowThreads(__tstate);
15370 if (PyErr_Occurred()) SWIG_fail;
15371 }
15372 {
15373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15374 }
15375 return resultobj;
15376 fail:
15377 return NULL;
15378 }
15379
15380
15381 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15382 PyObject *resultobj;
15383 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15384 PyObject * obj0 = 0 ;
15385 char *kwnames[] = {
15386 (char *) "self", NULL
15387 };
15388
15389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15391 if (SWIG_arg_fail(1)) SWIG_fail;
15392 {
15393 PyThreadState* __tstate = wxPyBeginAllowThreads();
15394 delete arg1;
15395
15396 wxPyEndAllowThreads(__tstate);
15397 if (PyErr_Occurred()) SWIG_fail;
15398 }
15399 Py_INCREF(Py_None); resultobj = Py_None;
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15407 PyObject *obj;
15408 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15409 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15410 Py_INCREF(obj);
15411 return Py_BuildValue((char *)"");
15412 }
15413 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15414 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15415 return 1;
15416 }
15417
15418
15419 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15420 PyObject *pyobj;
15421
15422 {
15423 #if wxUSE_UNICODE
15424 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15425 #else
15426 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15427 #endif
15428 }
15429 return pyobj;
15430 }
15431
15432
15433 static int _wrap_ART_MENU_set(PyObject *) {
15434 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15435 return 1;
15436 }
15437
15438
15439 static PyObject *_wrap_ART_MENU_get(void) {
15440 PyObject *pyobj;
15441
15442 {
15443 #if wxUSE_UNICODE
15444 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15445 #else
15446 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15447 #endif
15448 }
15449 return pyobj;
15450 }
15451
15452
15453 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15454 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15455 return 1;
15456 }
15457
15458
15459 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15460 PyObject *pyobj;
15461
15462 {
15463 #if wxUSE_UNICODE
15464 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15465 #else
15466 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15467 #endif
15468 }
15469 return pyobj;
15470 }
15471
15472
15473 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15474 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15475 return 1;
15476 }
15477
15478
15479 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15480 PyObject *pyobj;
15481
15482 {
15483 #if wxUSE_UNICODE
15484 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15485 #else
15486 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15487 #endif
15488 }
15489 return pyobj;
15490 }
15491
15492
15493 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15494 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15495 return 1;
15496 }
15497
15498
15499 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15500 PyObject *pyobj;
15501
15502 {
15503 #if wxUSE_UNICODE
15504 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15505 #else
15506 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15507 #endif
15508 }
15509 return pyobj;
15510 }
15511
15512
15513 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15514 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15515 return 1;
15516 }
15517
15518
15519 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15520 PyObject *pyobj;
15521
15522 {
15523 #if wxUSE_UNICODE
15524 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15525 #else
15526 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15527 #endif
15528 }
15529 return pyobj;
15530 }
15531
15532
15533 static int _wrap_ART_BUTTON_set(PyObject *) {
15534 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15535 return 1;
15536 }
15537
15538
15539 static PyObject *_wrap_ART_BUTTON_get(void) {
15540 PyObject *pyobj;
15541
15542 {
15543 #if wxUSE_UNICODE
15544 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15545 #else
15546 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15547 #endif
15548 }
15549 return pyobj;
15550 }
15551
15552
15553 static int _wrap_ART_OTHER_set(PyObject *) {
15554 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15555 return 1;
15556 }
15557
15558
15559 static PyObject *_wrap_ART_OTHER_get(void) {
15560 PyObject *pyobj;
15561
15562 {
15563 #if wxUSE_UNICODE
15564 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15565 #else
15566 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15567 #endif
15568 }
15569 return pyobj;
15570 }
15571
15572
15573 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15574 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15575 return 1;
15576 }
15577
15578
15579 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15580 PyObject *pyobj;
15581
15582 {
15583 #if wxUSE_UNICODE
15584 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15585 #else
15586 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15587 #endif
15588 }
15589 return pyobj;
15590 }
15591
15592
15593 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15594 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15595 return 1;
15596 }
15597
15598
15599 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15600 PyObject *pyobj;
15601
15602 {
15603 #if wxUSE_UNICODE
15604 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15605 #else
15606 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15607 #endif
15608 }
15609 return pyobj;
15610 }
15611
15612
15613 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15614 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15615 return 1;
15616 }
15617
15618
15619 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15620 PyObject *pyobj;
15621
15622 {
15623 #if wxUSE_UNICODE
15624 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15625 #else
15626 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15627 #endif
15628 }
15629 return pyobj;
15630 }
15631
15632
15633 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15634 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15635 return 1;
15636 }
15637
15638
15639 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15640 PyObject *pyobj;
15641
15642 {
15643 #if wxUSE_UNICODE
15644 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15645 #else
15646 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15647 #endif
15648 }
15649 return pyobj;
15650 }
15651
15652
15653 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15654 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15655 return 1;
15656 }
15657
15658
15659 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15660 PyObject *pyobj;
15661
15662 {
15663 #if wxUSE_UNICODE
15664 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15665 #else
15666 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15667 #endif
15668 }
15669 return pyobj;
15670 }
15671
15672
15673 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15674 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15675 return 1;
15676 }
15677
15678
15679 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15680 PyObject *pyobj;
15681
15682 {
15683 #if wxUSE_UNICODE
15684 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15685 #else
15686 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15687 #endif
15688 }
15689 return pyobj;
15690 }
15691
15692
15693 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15694 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15695 return 1;
15696 }
15697
15698
15699 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15700 PyObject *pyobj;
15701
15702 {
15703 #if wxUSE_UNICODE
15704 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15705 #else
15706 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15707 #endif
15708 }
15709 return pyobj;
15710 }
15711
15712
15713 static int _wrap_ART_GO_BACK_set(PyObject *) {
15714 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15715 return 1;
15716 }
15717
15718
15719 static PyObject *_wrap_ART_GO_BACK_get(void) {
15720 PyObject *pyobj;
15721
15722 {
15723 #if wxUSE_UNICODE
15724 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15725 #else
15726 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15727 #endif
15728 }
15729 return pyobj;
15730 }
15731
15732
15733 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15734 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15735 return 1;
15736 }
15737
15738
15739 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15740 PyObject *pyobj;
15741
15742 {
15743 #if wxUSE_UNICODE
15744 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15745 #else
15746 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15747 #endif
15748 }
15749 return pyobj;
15750 }
15751
15752
15753 static int _wrap_ART_GO_UP_set(PyObject *) {
15754 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15755 return 1;
15756 }
15757
15758
15759 static PyObject *_wrap_ART_GO_UP_get(void) {
15760 PyObject *pyobj;
15761
15762 {
15763 #if wxUSE_UNICODE
15764 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15765 #else
15766 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15767 #endif
15768 }
15769 return pyobj;
15770 }
15771
15772
15773 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15774 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15775 return 1;
15776 }
15777
15778
15779 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15780 PyObject *pyobj;
15781
15782 {
15783 #if wxUSE_UNICODE
15784 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15785 #else
15786 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15787 #endif
15788 }
15789 return pyobj;
15790 }
15791
15792
15793 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15794 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15795 return 1;
15796 }
15797
15798
15799 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15800 PyObject *pyobj;
15801
15802 {
15803 #if wxUSE_UNICODE
15804 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15805 #else
15806 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15807 #endif
15808 }
15809 return pyobj;
15810 }
15811
15812
15813 static int _wrap_ART_GO_HOME_set(PyObject *) {
15814 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15815 return 1;
15816 }
15817
15818
15819 static PyObject *_wrap_ART_GO_HOME_get(void) {
15820 PyObject *pyobj;
15821
15822 {
15823 #if wxUSE_UNICODE
15824 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15825 #else
15826 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15827 #endif
15828 }
15829 return pyobj;
15830 }
15831
15832
15833 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15834 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15835 return 1;
15836 }
15837
15838
15839 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15840 PyObject *pyobj;
15841
15842 {
15843 #if wxUSE_UNICODE
15844 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15845 #else
15846 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15847 #endif
15848 }
15849 return pyobj;
15850 }
15851
15852
15853 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15854 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15855 return 1;
15856 }
15857
15858
15859 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15860 PyObject *pyobj;
15861
15862 {
15863 #if wxUSE_UNICODE
15864 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15865 #else
15866 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15867 #endif
15868 }
15869 return pyobj;
15870 }
15871
15872
15873 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15874 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15875 return 1;
15876 }
15877
15878
15879 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15880 PyObject *pyobj;
15881
15882 {
15883 #if wxUSE_UNICODE
15884 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15885 #else
15886 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15887 #endif
15888 }
15889 return pyobj;
15890 }
15891
15892
15893 static int _wrap_ART_PRINT_set(PyObject *) {
15894 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15895 return 1;
15896 }
15897
15898
15899 static PyObject *_wrap_ART_PRINT_get(void) {
15900 PyObject *pyobj;
15901
15902 {
15903 #if wxUSE_UNICODE
15904 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15905 #else
15906 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15907 #endif
15908 }
15909 return pyobj;
15910 }
15911
15912
15913 static int _wrap_ART_HELP_set(PyObject *) {
15914 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15915 return 1;
15916 }
15917
15918
15919 static PyObject *_wrap_ART_HELP_get(void) {
15920 PyObject *pyobj;
15921
15922 {
15923 #if wxUSE_UNICODE
15924 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15925 #else
15926 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15927 #endif
15928 }
15929 return pyobj;
15930 }
15931
15932
15933 static int _wrap_ART_TIP_set(PyObject *) {
15934 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15935 return 1;
15936 }
15937
15938
15939 static PyObject *_wrap_ART_TIP_get(void) {
15940 PyObject *pyobj;
15941
15942 {
15943 #if wxUSE_UNICODE
15944 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15945 #else
15946 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15947 #endif
15948 }
15949 return pyobj;
15950 }
15951
15952
15953 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15954 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15955 return 1;
15956 }
15957
15958
15959 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15960 PyObject *pyobj;
15961
15962 {
15963 #if wxUSE_UNICODE
15964 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15965 #else
15966 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15967 #endif
15968 }
15969 return pyobj;
15970 }
15971
15972
15973 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15974 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15975 return 1;
15976 }
15977
15978
15979 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15980 PyObject *pyobj;
15981
15982 {
15983 #if wxUSE_UNICODE
15984 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15985 #else
15986 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15987 #endif
15988 }
15989 return pyobj;
15990 }
15991
15992
15993 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15994 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15995 return 1;
15996 }
15997
15998
15999 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16000 PyObject *pyobj;
16001
16002 {
16003 #if wxUSE_UNICODE
16004 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16005 #else
16006 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16007 #endif
16008 }
16009 return pyobj;
16010 }
16011
16012
16013 static int _wrap_ART_HARDDISK_set(PyObject *) {
16014 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16015 return 1;
16016 }
16017
16018
16019 static PyObject *_wrap_ART_HARDDISK_get(void) {
16020 PyObject *pyobj;
16021
16022 {
16023 #if wxUSE_UNICODE
16024 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16025 #else
16026 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16027 #endif
16028 }
16029 return pyobj;
16030 }
16031
16032
16033 static int _wrap_ART_FLOPPY_set(PyObject *) {
16034 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16035 return 1;
16036 }
16037
16038
16039 static PyObject *_wrap_ART_FLOPPY_get(void) {
16040 PyObject *pyobj;
16041
16042 {
16043 #if wxUSE_UNICODE
16044 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16045 #else
16046 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16047 #endif
16048 }
16049 return pyobj;
16050 }
16051
16052
16053 static int _wrap_ART_CDROM_set(PyObject *) {
16054 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16055 return 1;
16056 }
16057
16058
16059 static PyObject *_wrap_ART_CDROM_get(void) {
16060 PyObject *pyobj;
16061
16062 {
16063 #if wxUSE_UNICODE
16064 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16065 #else
16066 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16067 #endif
16068 }
16069 return pyobj;
16070 }
16071
16072
16073 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16074 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16075 return 1;
16076 }
16077
16078
16079 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16080 PyObject *pyobj;
16081
16082 {
16083 #if wxUSE_UNICODE
16084 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16085 #else
16086 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16087 #endif
16088 }
16089 return pyobj;
16090 }
16091
16092
16093 static int _wrap_ART_FOLDER_set(PyObject *) {
16094 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16095 return 1;
16096 }
16097
16098
16099 static PyObject *_wrap_ART_FOLDER_get(void) {
16100 PyObject *pyobj;
16101
16102 {
16103 #if wxUSE_UNICODE
16104 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16105 #else
16106 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16107 #endif
16108 }
16109 return pyobj;
16110 }
16111
16112
16113 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16114 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16115 return 1;
16116 }
16117
16118
16119 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16120 PyObject *pyobj;
16121
16122 {
16123 #if wxUSE_UNICODE
16124 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16125 #else
16126 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16127 #endif
16128 }
16129 return pyobj;
16130 }
16131
16132
16133 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16134 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16135 return 1;
16136 }
16137
16138
16139 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16140 PyObject *pyobj;
16141
16142 {
16143 #if wxUSE_UNICODE
16144 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16145 #else
16146 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16147 #endif
16148 }
16149 return pyobj;
16150 }
16151
16152
16153 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16154 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16155 return 1;
16156 }
16157
16158
16159 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16160 PyObject *pyobj;
16161
16162 {
16163 #if wxUSE_UNICODE
16164 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16165 #else
16166 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16167 #endif
16168 }
16169 return pyobj;
16170 }
16171
16172
16173 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16174 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16175 return 1;
16176 }
16177
16178
16179 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16180 PyObject *pyobj;
16181
16182 {
16183 #if wxUSE_UNICODE
16184 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16185 #else
16186 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16187 #endif
16188 }
16189 return pyobj;
16190 }
16191
16192
16193 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16194 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16195 return 1;
16196 }
16197
16198
16199 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16200 PyObject *pyobj;
16201
16202 {
16203 #if wxUSE_UNICODE
16204 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16205 #else
16206 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16207 #endif
16208 }
16209 return pyobj;
16210 }
16211
16212
16213 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16214 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16215 return 1;
16216 }
16217
16218
16219 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16220 PyObject *pyobj;
16221
16222 {
16223 #if wxUSE_UNICODE
16224 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16225 #else
16226 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16227 #endif
16228 }
16229 return pyobj;
16230 }
16231
16232
16233 static int _wrap_ART_ERROR_set(PyObject *) {
16234 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16235 return 1;
16236 }
16237
16238
16239 static PyObject *_wrap_ART_ERROR_get(void) {
16240 PyObject *pyobj;
16241
16242 {
16243 #if wxUSE_UNICODE
16244 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16245 #else
16246 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16247 #endif
16248 }
16249 return pyobj;
16250 }
16251
16252
16253 static int _wrap_ART_QUESTION_set(PyObject *) {
16254 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16255 return 1;
16256 }
16257
16258
16259 static PyObject *_wrap_ART_QUESTION_get(void) {
16260 PyObject *pyobj;
16261
16262 {
16263 #if wxUSE_UNICODE
16264 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16265 #else
16266 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16267 #endif
16268 }
16269 return pyobj;
16270 }
16271
16272
16273 static int _wrap_ART_WARNING_set(PyObject *) {
16274 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16275 return 1;
16276 }
16277
16278
16279 static PyObject *_wrap_ART_WARNING_get(void) {
16280 PyObject *pyobj;
16281
16282 {
16283 #if wxUSE_UNICODE
16284 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16285 #else
16286 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16287 #endif
16288 }
16289 return pyobj;
16290 }
16291
16292
16293 static int _wrap_ART_INFORMATION_set(PyObject *) {
16294 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16295 return 1;
16296 }
16297
16298
16299 static PyObject *_wrap_ART_INFORMATION_get(void) {
16300 PyObject *pyobj;
16301
16302 {
16303 #if wxUSE_UNICODE
16304 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16305 #else
16306 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16307 #endif
16308 }
16309 return pyobj;
16310 }
16311
16312
16313 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16314 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16315 return 1;
16316 }
16317
16318
16319 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16320 PyObject *pyobj;
16321
16322 {
16323 #if wxUSE_UNICODE
16324 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16325 #else
16326 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16327 #endif
16328 }
16329 return pyobj;
16330 }
16331
16332
16333 static int _wrap_ART_COPY_set(PyObject *) {
16334 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16335 return 1;
16336 }
16337
16338
16339 static PyObject *_wrap_ART_COPY_get(void) {
16340 PyObject *pyobj;
16341
16342 {
16343 #if wxUSE_UNICODE
16344 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16345 #else
16346 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16347 #endif
16348 }
16349 return pyobj;
16350 }
16351
16352
16353 static int _wrap_ART_CUT_set(PyObject *) {
16354 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16355 return 1;
16356 }
16357
16358
16359 static PyObject *_wrap_ART_CUT_get(void) {
16360 PyObject *pyobj;
16361
16362 {
16363 #if wxUSE_UNICODE
16364 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16365 #else
16366 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16367 #endif
16368 }
16369 return pyobj;
16370 }
16371
16372
16373 static int _wrap_ART_PASTE_set(PyObject *) {
16374 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16375 return 1;
16376 }
16377
16378
16379 static PyObject *_wrap_ART_PASTE_get(void) {
16380 PyObject *pyobj;
16381
16382 {
16383 #if wxUSE_UNICODE
16384 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16385 #else
16386 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16387 #endif
16388 }
16389 return pyobj;
16390 }
16391
16392
16393 static int _wrap_ART_DELETE_set(PyObject *) {
16394 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16395 return 1;
16396 }
16397
16398
16399 static PyObject *_wrap_ART_DELETE_get(void) {
16400 PyObject *pyobj;
16401
16402 {
16403 #if wxUSE_UNICODE
16404 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16405 #else
16406 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16407 #endif
16408 }
16409 return pyobj;
16410 }
16411
16412
16413 static int _wrap_ART_UNDO_set(PyObject *) {
16414 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16415 return 1;
16416 }
16417
16418
16419 static PyObject *_wrap_ART_UNDO_get(void) {
16420 PyObject *pyobj;
16421
16422 {
16423 #if wxUSE_UNICODE
16424 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16425 #else
16426 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16427 #endif
16428 }
16429 return pyobj;
16430 }
16431
16432
16433 static int _wrap_ART_REDO_set(PyObject *) {
16434 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16435 return 1;
16436 }
16437
16438
16439 static PyObject *_wrap_ART_REDO_get(void) {
16440 PyObject *pyobj;
16441
16442 {
16443 #if wxUSE_UNICODE
16444 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16445 #else
16446 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16447 #endif
16448 }
16449 return pyobj;
16450 }
16451
16452
16453 static int _wrap_ART_QUIT_set(PyObject *) {
16454 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16455 return 1;
16456 }
16457
16458
16459 static PyObject *_wrap_ART_QUIT_get(void) {
16460 PyObject *pyobj;
16461
16462 {
16463 #if wxUSE_UNICODE
16464 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16465 #else
16466 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16467 #endif
16468 }
16469 return pyobj;
16470 }
16471
16472
16473 static int _wrap_ART_FIND_set(PyObject *) {
16474 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16475 return 1;
16476 }
16477
16478
16479 static PyObject *_wrap_ART_FIND_get(void) {
16480 PyObject *pyobj;
16481
16482 {
16483 #if wxUSE_UNICODE
16484 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16485 #else
16486 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16487 #endif
16488 }
16489 return pyobj;
16490 }
16491
16492
16493 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16494 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16495 return 1;
16496 }
16497
16498
16499 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16500 PyObject *pyobj;
16501
16502 {
16503 #if wxUSE_UNICODE
16504 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16505 #else
16506 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16507 #endif
16508 }
16509 return pyobj;
16510 }
16511
16512
16513 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16514 PyObject *resultobj;
16515 wxPyArtProvider *result;
16516 char *kwnames[] = {
16517 NULL
16518 };
16519
16520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16521 {
16522 if (!wxPyCheckForApp()) SWIG_fail;
16523 PyThreadState* __tstate = wxPyBeginAllowThreads();
16524 result = (wxPyArtProvider *)new wxPyArtProvider();
16525
16526 wxPyEndAllowThreads(__tstate);
16527 if (PyErr_Occurred()) SWIG_fail;
16528 }
16529 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16530 return resultobj;
16531 fail:
16532 return NULL;
16533 }
16534
16535
16536 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16537 PyObject *resultobj;
16538 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16539 PyObject *arg2 = (PyObject *) 0 ;
16540 PyObject *arg3 = (PyObject *) 0 ;
16541 PyObject * obj0 = 0 ;
16542 PyObject * obj1 = 0 ;
16543 PyObject * obj2 = 0 ;
16544 char *kwnames[] = {
16545 (char *) "self",(char *) "self",(char *) "_class", NULL
16546 };
16547
16548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16550 if (SWIG_arg_fail(1)) SWIG_fail;
16551 arg2 = obj1;
16552 arg3 = obj2;
16553 {
16554 PyThreadState* __tstate = wxPyBeginAllowThreads();
16555 (arg1)->_setCallbackInfo(arg2,arg3);
16556
16557 wxPyEndAllowThreads(__tstate);
16558 if (PyErr_Occurred()) SWIG_fail;
16559 }
16560 Py_INCREF(Py_None); resultobj = Py_None;
16561 return resultobj;
16562 fail:
16563 return NULL;
16564 }
16565
16566
16567 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16568 PyObject *resultobj;
16569 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16570 PyObject * obj0 = 0 ;
16571 char *kwnames[] = {
16572 (char *) "provider", NULL
16573 };
16574
16575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16577 if (SWIG_arg_fail(1)) SWIG_fail;
16578 {
16579 PyThreadState* __tstate = wxPyBeginAllowThreads();
16580 wxPyArtProvider::PushProvider(arg1);
16581
16582 wxPyEndAllowThreads(__tstate);
16583 if (PyErr_Occurred()) SWIG_fail;
16584 }
16585 Py_INCREF(Py_None); resultobj = Py_None;
16586 return resultobj;
16587 fail:
16588 return NULL;
16589 }
16590
16591
16592 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16593 PyObject *resultobj;
16594 bool result;
16595 char *kwnames[] = {
16596 NULL
16597 };
16598
16599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16600 {
16601 PyThreadState* __tstate = wxPyBeginAllowThreads();
16602 result = (bool)wxPyArtProvider::PopProvider();
16603
16604 wxPyEndAllowThreads(__tstate);
16605 if (PyErr_Occurred()) SWIG_fail;
16606 }
16607 {
16608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16609 }
16610 return resultobj;
16611 fail:
16612 return NULL;
16613 }
16614
16615
16616 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16617 PyObject *resultobj;
16618 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16619 bool result;
16620 PyObject * obj0 = 0 ;
16621 char *kwnames[] = {
16622 (char *) "provider", NULL
16623 };
16624
16625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16627 if (SWIG_arg_fail(1)) SWIG_fail;
16628 {
16629 PyThreadState* __tstate = wxPyBeginAllowThreads();
16630 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16631
16632 wxPyEndAllowThreads(__tstate);
16633 if (PyErr_Occurred()) SWIG_fail;
16634 }
16635 {
16636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16637 }
16638 return resultobj;
16639 fail:
16640 return NULL;
16641 }
16642
16643
16644 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16645 PyObject *resultobj;
16646 wxString *arg1 = 0 ;
16647 wxString const &arg2_defvalue = wxPyART_OTHER ;
16648 wxString *arg2 = (wxString *) &arg2_defvalue ;
16649 wxSize const &arg3_defvalue = wxDefaultSize ;
16650 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16651 wxBitmap result;
16652 bool temp1 = false ;
16653 bool temp2 = false ;
16654 wxSize temp3 ;
16655 PyObject * obj0 = 0 ;
16656 PyObject * obj1 = 0 ;
16657 PyObject * obj2 = 0 ;
16658 char *kwnames[] = {
16659 (char *) "id",(char *) "client",(char *) "size", NULL
16660 };
16661
16662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16663 {
16664 arg1 = wxString_in_helper(obj0);
16665 if (arg1 == NULL) SWIG_fail;
16666 temp1 = true;
16667 }
16668 if (obj1) {
16669 {
16670 arg2 = wxString_in_helper(obj1);
16671 if (arg2 == NULL) SWIG_fail;
16672 temp2 = true;
16673 }
16674 }
16675 if (obj2) {
16676 {
16677 arg3 = &temp3;
16678 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16679 }
16680 }
16681 {
16682 if (!wxPyCheckForApp()) SWIG_fail;
16683 PyThreadState* __tstate = wxPyBeginAllowThreads();
16684 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16685
16686 wxPyEndAllowThreads(__tstate);
16687 if (PyErr_Occurred()) SWIG_fail;
16688 }
16689 {
16690 wxBitmap * resultptr;
16691 resultptr = new wxBitmap((wxBitmap &)(result));
16692 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16693 }
16694 {
16695 if (temp1)
16696 delete arg1;
16697 }
16698 {
16699 if (temp2)
16700 delete arg2;
16701 }
16702 return resultobj;
16703 fail:
16704 {
16705 if (temp1)
16706 delete arg1;
16707 }
16708 {
16709 if (temp2)
16710 delete arg2;
16711 }
16712 return NULL;
16713 }
16714
16715
16716 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16717 PyObject *resultobj;
16718 wxString *arg1 = 0 ;
16719 wxString const &arg2_defvalue = wxPyART_OTHER ;
16720 wxString *arg2 = (wxString *) &arg2_defvalue ;
16721 wxSize const &arg3_defvalue = wxDefaultSize ;
16722 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16723 wxIcon result;
16724 bool temp1 = false ;
16725 bool temp2 = false ;
16726 wxSize temp3 ;
16727 PyObject * obj0 = 0 ;
16728 PyObject * obj1 = 0 ;
16729 PyObject * obj2 = 0 ;
16730 char *kwnames[] = {
16731 (char *) "id",(char *) "client",(char *) "size", NULL
16732 };
16733
16734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16735 {
16736 arg1 = wxString_in_helper(obj0);
16737 if (arg1 == NULL) SWIG_fail;
16738 temp1 = true;
16739 }
16740 if (obj1) {
16741 {
16742 arg2 = wxString_in_helper(obj1);
16743 if (arg2 == NULL) SWIG_fail;
16744 temp2 = true;
16745 }
16746 }
16747 if (obj2) {
16748 {
16749 arg3 = &temp3;
16750 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16751 }
16752 }
16753 {
16754 if (!wxPyCheckForApp()) SWIG_fail;
16755 PyThreadState* __tstate = wxPyBeginAllowThreads();
16756 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16757
16758 wxPyEndAllowThreads(__tstate);
16759 if (PyErr_Occurred()) SWIG_fail;
16760 }
16761 {
16762 wxIcon * resultptr;
16763 resultptr = new wxIcon((wxIcon &)(result));
16764 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16765 }
16766 {
16767 if (temp1)
16768 delete arg1;
16769 }
16770 {
16771 if (temp2)
16772 delete arg2;
16773 }
16774 return resultobj;
16775 fail:
16776 {
16777 if (temp1)
16778 delete arg1;
16779 }
16780 {
16781 if (temp2)
16782 delete arg2;
16783 }
16784 return NULL;
16785 }
16786
16787
16788 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16789 PyObject *resultobj;
16790 wxString *arg1 = 0 ;
16791 bool arg2 = (bool) false ;
16792 wxSize result;
16793 bool temp1 = false ;
16794 PyObject * obj0 = 0 ;
16795 PyObject * obj1 = 0 ;
16796 char *kwnames[] = {
16797 (char *) "client",(char *) "platform_dependent", NULL
16798 };
16799
16800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16801 {
16802 arg1 = wxString_in_helper(obj0);
16803 if (arg1 == NULL) SWIG_fail;
16804 temp1 = true;
16805 }
16806 if (obj1) {
16807 {
16808 arg2 = (bool)(SWIG_As_bool(obj1));
16809 if (SWIG_arg_fail(2)) SWIG_fail;
16810 }
16811 }
16812 {
16813 PyThreadState* __tstate = wxPyBeginAllowThreads();
16814 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16815
16816 wxPyEndAllowThreads(__tstate);
16817 if (PyErr_Occurred()) SWIG_fail;
16818 }
16819 {
16820 wxSize * resultptr;
16821 resultptr = new wxSize((wxSize &)(result));
16822 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16823 }
16824 {
16825 if (temp1)
16826 delete arg1;
16827 }
16828 return resultobj;
16829 fail:
16830 {
16831 if (temp1)
16832 delete arg1;
16833 }
16834 return NULL;
16835 }
16836
16837
16838 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16839 PyObject *resultobj;
16840 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16841 PyObject * obj0 = 0 ;
16842 char *kwnames[] = {
16843 (char *) "self", NULL
16844 };
16845
16846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16848 if (SWIG_arg_fail(1)) SWIG_fail;
16849 {
16850 PyThreadState* __tstate = wxPyBeginAllowThreads();
16851 wxPyArtProvider_Destroy(arg1);
16852
16853 wxPyEndAllowThreads(__tstate);
16854 if (PyErr_Occurred()) SWIG_fail;
16855 }
16856 Py_INCREF(Py_None); resultobj = Py_None;
16857 return resultobj;
16858 fail:
16859 return NULL;
16860 }
16861
16862
16863 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16864 PyObject *obj;
16865 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16866 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16867 Py_INCREF(obj);
16868 return Py_BuildValue((char *)"");
16869 }
16870 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16871 PyObject *resultobj;
16872 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16873 PyObject * obj0 = 0 ;
16874 char *kwnames[] = {
16875 (char *) "self", NULL
16876 };
16877
16878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16880 if (SWIG_arg_fail(1)) SWIG_fail;
16881 {
16882 PyThreadState* __tstate = wxPyBeginAllowThreads();
16883 delete arg1;
16884
16885 wxPyEndAllowThreads(__tstate);
16886 if (PyErr_Occurred()) SWIG_fail;
16887 }
16888 Py_INCREF(Py_None); resultobj = Py_None;
16889 return resultobj;
16890 fail:
16891 return NULL;
16892 }
16893
16894
16895 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16896 PyObject *resultobj;
16897 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16898 wxConfigBase *result;
16899 PyObject * obj0 = 0 ;
16900 char *kwnames[] = {
16901 (char *) "config", NULL
16902 };
16903
16904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16906 if (SWIG_arg_fail(1)) SWIG_fail;
16907 {
16908 PyThreadState* __tstate = wxPyBeginAllowThreads();
16909 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16910
16911 wxPyEndAllowThreads(__tstate);
16912 if (PyErr_Occurred()) SWIG_fail;
16913 }
16914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16915 return resultobj;
16916 fail:
16917 return NULL;
16918 }
16919
16920
16921 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16922 PyObject *resultobj;
16923 bool arg1 = (bool) true ;
16924 wxConfigBase *result;
16925 PyObject * obj0 = 0 ;
16926 char *kwnames[] = {
16927 (char *) "createOnDemand", NULL
16928 };
16929
16930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16931 if (obj0) {
16932 {
16933 arg1 = (bool)(SWIG_As_bool(obj0));
16934 if (SWIG_arg_fail(1)) SWIG_fail;
16935 }
16936 }
16937 {
16938 PyThreadState* __tstate = wxPyBeginAllowThreads();
16939 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16940
16941 wxPyEndAllowThreads(__tstate);
16942 if (PyErr_Occurred()) SWIG_fail;
16943 }
16944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16945 return resultobj;
16946 fail:
16947 return NULL;
16948 }
16949
16950
16951 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16952 PyObject *resultobj;
16953 wxConfigBase *result;
16954 char *kwnames[] = {
16955 NULL
16956 };
16957
16958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16959 {
16960 PyThreadState* __tstate = wxPyBeginAllowThreads();
16961 result = (wxConfigBase *)wxConfigBase::Create();
16962
16963 wxPyEndAllowThreads(__tstate);
16964 if (PyErr_Occurred()) SWIG_fail;
16965 }
16966 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16967 return resultobj;
16968 fail:
16969 return NULL;
16970 }
16971
16972
16973 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16974 PyObject *resultobj;
16975 char *kwnames[] = {
16976 NULL
16977 };
16978
16979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16980 {
16981 PyThreadState* __tstate = wxPyBeginAllowThreads();
16982 wxConfigBase::DontCreateOnDemand();
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_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16995 PyObject *resultobj;
16996 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16997 wxString *arg2 = 0 ;
16998 bool temp2 = false ;
16999 PyObject * obj0 = 0 ;
17000 PyObject * obj1 = 0 ;
17001 char *kwnames[] = {
17002 (char *) "self",(char *) "path", NULL
17003 };
17004
17005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17007 if (SWIG_arg_fail(1)) SWIG_fail;
17008 {
17009 arg2 = wxString_in_helper(obj1);
17010 if (arg2 == NULL) SWIG_fail;
17011 temp2 = true;
17012 }
17013 {
17014 PyThreadState* __tstate = wxPyBeginAllowThreads();
17015 (arg1)->SetPath((wxString const &)*arg2);
17016
17017 wxPyEndAllowThreads(__tstate);
17018 if (PyErr_Occurred()) SWIG_fail;
17019 }
17020 Py_INCREF(Py_None); resultobj = Py_None;
17021 {
17022 if (temp2)
17023 delete arg2;
17024 }
17025 return resultobj;
17026 fail:
17027 {
17028 if (temp2)
17029 delete arg2;
17030 }
17031 return NULL;
17032 }
17033
17034
17035 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17036 PyObject *resultobj;
17037 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17038 wxString *result;
17039 PyObject * obj0 = 0 ;
17040 char *kwnames[] = {
17041 (char *) "self", NULL
17042 };
17043
17044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17046 if (SWIG_arg_fail(1)) SWIG_fail;
17047 {
17048 PyThreadState* __tstate = wxPyBeginAllowThreads();
17049 {
17050 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17051 result = (wxString *) &_result_ref;
17052 }
17053
17054 wxPyEndAllowThreads(__tstate);
17055 if (PyErr_Occurred()) SWIG_fail;
17056 }
17057 {
17058 #if wxUSE_UNICODE
17059 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17060 #else
17061 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17062 #endif
17063 }
17064 return resultobj;
17065 fail:
17066 return NULL;
17067 }
17068
17069
17070 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17071 PyObject *resultobj;
17072 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17073 PyObject *result;
17074 PyObject * obj0 = 0 ;
17075 char *kwnames[] = {
17076 (char *) "self", NULL
17077 };
17078
17079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17081 if (SWIG_arg_fail(1)) SWIG_fail;
17082 {
17083 PyThreadState* __tstate = wxPyBeginAllowThreads();
17084 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17085
17086 wxPyEndAllowThreads(__tstate);
17087 if (PyErr_Occurred()) SWIG_fail;
17088 }
17089 resultobj = result;
17090 return resultobj;
17091 fail:
17092 return NULL;
17093 }
17094
17095
17096 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17097 PyObject *resultobj;
17098 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17099 long arg2 ;
17100 PyObject *result;
17101 PyObject * obj0 = 0 ;
17102 PyObject * obj1 = 0 ;
17103 char *kwnames[] = {
17104 (char *) "self",(char *) "index", NULL
17105 };
17106
17107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17109 if (SWIG_arg_fail(1)) SWIG_fail;
17110 {
17111 arg2 = (long)(SWIG_As_long(obj1));
17112 if (SWIG_arg_fail(2)) SWIG_fail;
17113 }
17114 {
17115 PyThreadState* __tstate = wxPyBeginAllowThreads();
17116 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17117
17118 wxPyEndAllowThreads(__tstate);
17119 if (PyErr_Occurred()) SWIG_fail;
17120 }
17121 resultobj = result;
17122 return resultobj;
17123 fail:
17124 return NULL;
17125 }
17126
17127
17128 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17129 PyObject *resultobj;
17130 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17131 PyObject *result;
17132 PyObject * obj0 = 0 ;
17133 char *kwnames[] = {
17134 (char *) "self", NULL
17135 };
17136
17137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17139 if (SWIG_arg_fail(1)) SWIG_fail;
17140 {
17141 PyThreadState* __tstate = wxPyBeginAllowThreads();
17142 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17143
17144 wxPyEndAllowThreads(__tstate);
17145 if (PyErr_Occurred()) SWIG_fail;
17146 }
17147 resultobj = result;
17148 return resultobj;
17149 fail:
17150 return NULL;
17151 }
17152
17153
17154 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17155 PyObject *resultobj;
17156 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17157 long arg2 ;
17158 PyObject *result;
17159 PyObject * obj0 = 0 ;
17160 PyObject * obj1 = 0 ;
17161 char *kwnames[] = {
17162 (char *) "self",(char *) "index", NULL
17163 };
17164
17165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17167 if (SWIG_arg_fail(1)) SWIG_fail;
17168 {
17169 arg2 = (long)(SWIG_As_long(obj1));
17170 if (SWIG_arg_fail(2)) SWIG_fail;
17171 }
17172 {
17173 PyThreadState* __tstate = wxPyBeginAllowThreads();
17174 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17175
17176 wxPyEndAllowThreads(__tstate);
17177 if (PyErr_Occurred()) SWIG_fail;
17178 }
17179 resultobj = result;
17180 return resultobj;
17181 fail:
17182 return NULL;
17183 }
17184
17185
17186 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17187 PyObject *resultobj;
17188 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17189 bool arg2 = (bool) false ;
17190 size_t result;
17191 PyObject * obj0 = 0 ;
17192 PyObject * obj1 = 0 ;
17193 char *kwnames[] = {
17194 (char *) "self",(char *) "recursive", NULL
17195 };
17196
17197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17199 if (SWIG_arg_fail(1)) SWIG_fail;
17200 if (obj1) {
17201 {
17202 arg2 = (bool)(SWIG_As_bool(obj1));
17203 if (SWIG_arg_fail(2)) SWIG_fail;
17204 }
17205 }
17206 {
17207 PyThreadState* __tstate = wxPyBeginAllowThreads();
17208 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17209
17210 wxPyEndAllowThreads(__tstate);
17211 if (PyErr_Occurred()) SWIG_fail;
17212 }
17213 {
17214 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17215 }
17216 return resultobj;
17217 fail:
17218 return NULL;
17219 }
17220
17221
17222 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17223 PyObject *resultobj;
17224 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17225 bool arg2 = (bool) false ;
17226 size_t result;
17227 PyObject * obj0 = 0 ;
17228 PyObject * obj1 = 0 ;
17229 char *kwnames[] = {
17230 (char *) "self",(char *) "recursive", NULL
17231 };
17232
17233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17235 if (SWIG_arg_fail(1)) SWIG_fail;
17236 if (obj1) {
17237 {
17238 arg2 = (bool)(SWIG_As_bool(obj1));
17239 if (SWIG_arg_fail(2)) SWIG_fail;
17240 }
17241 }
17242 {
17243 PyThreadState* __tstate = wxPyBeginAllowThreads();
17244 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17245
17246 wxPyEndAllowThreads(__tstate);
17247 if (PyErr_Occurred()) SWIG_fail;
17248 }
17249 {
17250 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17251 }
17252 return resultobj;
17253 fail:
17254 return NULL;
17255 }
17256
17257
17258 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17259 PyObject *resultobj;
17260 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17261 wxString *arg2 = 0 ;
17262 bool result;
17263 bool temp2 = false ;
17264 PyObject * obj0 = 0 ;
17265 PyObject * obj1 = 0 ;
17266 char *kwnames[] = {
17267 (char *) "self",(char *) "name", NULL
17268 };
17269
17270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17272 if (SWIG_arg_fail(1)) SWIG_fail;
17273 {
17274 arg2 = wxString_in_helper(obj1);
17275 if (arg2 == NULL) SWIG_fail;
17276 temp2 = true;
17277 }
17278 {
17279 PyThreadState* __tstate = wxPyBeginAllowThreads();
17280 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17281
17282 wxPyEndAllowThreads(__tstate);
17283 if (PyErr_Occurred()) SWIG_fail;
17284 }
17285 {
17286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17287 }
17288 {
17289 if (temp2)
17290 delete arg2;
17291 }
17292 return resultobj;
17293 fail:
17294 {
17295 if (temp2)
17296 delete arg2;
17297 }
17298 return NULL;
17299 }
17300
17301
17302 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17303 PyObject *resultobj;
17304 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17305 wxString *arg2 = 0 ;
17306 bool result;
17307 bool temp2 = false ;
17308 PyObject * obj0 = 0 ;
17309 PyObject * obj1 = 0 ;
17310 char *kwnames[] = {
17311 (char *) "self",(char *) "name", NULL
17312 };
17313
17314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17316 if (SWIG_arg_fail(1)) SWIG_fail;
17317 {
17318 arg2 = wxString_in_helper(obj1);
17319 if (arg2 == NULL) SWIG_fail;
17320 temp2 = true;
17321 }
17322 {
17323 PyThreadState* __tstate = wxPyBeginAllowThreads();
17324 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17325
17326 wxPyEndAllowThreads(__tstate);
17327 if (PyErr_Occurred()) SWIG_fail;
17328 }
17329 {
17330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17331 }
17332 {
17333 if (temp2)
17334 delete arg2;
17335 }
17336 return resultobj;
17337 fail:
17338 {
17339 if (temp2)
17340 delete arg2;
17341 }
17342 return NULL;
17343 }
17344
17345
17346 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17347 PyObject *resultobj;
17348 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17349 wxString *arg2 = 0 ;
17350 bool result;
17351 bool temp2 = false ;
17352 PyObject * obj0 = 0 ;
17353 PyObject * obj1 = 0 ;
17354 char *kwnames[] = {
17355 (char *) "self",(char *) "name", NULL
17356 };
17357
17358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17360 if (SWIG_arg_fail(1)) SWIG_fail;
17361 {
17362 arg2 = wxString_in_helper(obj1);
17363 if (arg2 == NULL) SWIG_fail;
17364 temp2 = true;
17365 }
17366 {
17367 PyThreadState* __tstate = wxPyBeginAllowThreads();
17368 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17369
17370 wxPyEndAllowThreads(__tstate);
17371 if (PyErr_Occurred()) SWIG_fail;
17372 }
17373 {
17374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17375 }
17376 {
17377 if (temp2)
17378 delete arg2;
17379 }
17380 return resultobj;
17381 fail:
17382 {
17383 if (temp2)
17384 delete arg2;
17385 }
17386 return NULL;
17387 }
17388
17389
17390 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17391 PyObject *resultobj;
17392 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17393 wxString *arg2 = 0 ;
17394 wxConfigBase::EntryType result;
17395 bool temp2 = false ;
17396 PyObject * obj0 = 0 ;
17397 PyObject * obj1 = 0 ;
17398 char *kwnames[] = {
17399 (char *) "self",(char *) "name", NULL
17400 };
17401
17402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17404 if (SWIG_arg_fail(1)) SWIG_fail;
17405 {
17406 arg2 = wxString_in_helper(obj1);
17407 if (arg2 == NULL) SWIG_fail;
17408 temp2 = true;
17409 }
17410 {
17411 PyThreadState* __tstate = wxPyBeginAllowThreads();
17412 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17413
17414 wxPyEndAllowThreads(__tstate);
17415 if (PyErr_Occurred()) SWIG_fail;
17416 }
17417 resultobj = SWIG_From_int((result));
17418 {
17419 if (temp2)
17420 delete arg2;
17421 }
17422 return resultobj;
17423 fail:
17424 {
17425 if (temp2)
17426 delete arg2;
17427 }
17428 return NULL;
17429 }
17430
17431
17432 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17433 PyObject *resultobj;
17434 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17435 wxString *arg2 = 0 ;
17436 wxString const &arg3_defvalue = wxPyEmptyString ;
17437 wxString *arg3 = (wxString *) &arg3_defvalue ;
17438 wxString result;
17439 bool temp2 = false ;
17440 bool temp3 = false ;
17441 PyObject * obj0 = 0 ;
17442 PyObject * obj1 = 0 ;
17443 PyObject * obj2 = 0 ;
17444 char *kwnames[] = {
17445 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17446 };
17447
17448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17450 if (SWIG_arg_fail(1)) SWIG_fail;
17451 {
17452 arg2 = wxString_in_helper(obj1);
17453 if (arg2 == NULL) SWIG_fail;
17454 temp2 = true;
17455 }
17456 if (obj2) {
17457 {
17458 arg3 = wxString_in_helper(obj2);
17459 if (arg3 == NULL) SWIG_fail;
17460 temp3 = true;
17461 }
17462 }
17463 {
17464 PyThreadState* __tstate = wxPyBeginAllowThreads();
17465 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17466
17467 wxPyEndAllowThreads(__tstate);
17468 if (PyErr_Occurred()) SWIG_fail;
17469 }
17470 {
17471 #if wxUSE_UNICODE
17472 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17473 #else
17474 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17475 #endif
17476 }
17477 {
17478 if (temp2)
17479 delete arg2;
17480 }
17481 {
17482 if (temp3)
17483 delete arg3;
17484 }
17485 return resultobj;
17486 fail:
17487 {
17488 if (temp2)
17489 delete arg2;
17490 }
17491 {
17492 if (temp3)
17493 delete arg3;
17494 }
17495 return NULL;
17496 }
17497
17498
17499 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17500 PyObject *resultobj;
17501 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17502 wxString *arg2 = 0 ;
17503 long arg3 = (long) 0 ;
17504 long result;
17505 bool temp2 = false ;
17506 PyObject * obj0 = 0 ;
17507 PyObject * obj1 = 0 ;
17508 PyObject * obj2 = 0 ;
17509 char *kwnames[] = {
17510 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17511 };
17512
17513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17515 if (SWIG_arg_fail(1)) SWIG_fail;
17516 {
17517 arg2 = wxString_in_helper(obj1);
17518 if (arg2 == NULL) SWIG_fail;
17519 temp2 = true;
17520 }
17521 if (obj2) {
17522 {
17523 arg3 = (long)(SWIG_As_long(obj2));
17524 if (SWIG_arg_fail(3)) SWIG_fail;
17525 }
17526 }
17527 {
17528 PyThreadState* __tstate = wxPyBeginAllowThreads();
17529 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17530
17531 wxPyEndAllowThreads(__tstate);
17532 if (PyErr_Occurred()) SWIG_fail;
17533 }
17534 {
17535 resultobj = SWIG_From_long((long)(result));
17536 }
17537 {
17538 if (temp2)
17539 delete arg2;
17540 }
17541 return resultobj;
17542 fail:
17543 {
17544 if (temp2)
17545 delete arg2;
17546 }
17547 return NULL;
17548 }
17549
17550
17551 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17552 PyObject *resultobj;
17553 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17554 wxString *arg2 = 0 ;
17555 double arg3 = (double) 0.0 ;
17556 double result;
17557 bool temp2 = false ;
17558 PyObject * obj0 = 0 ;
17559 PyObject * obj1 = 0 ;
17560 PyObject * obj2 = 0 ;
17561 char *kwnames[] = {
17562 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17563 };
17564
17565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17567 if (SWIG_arg_fail(1)) SWIG_fail;
17568 {
17569 arg2 = wxString_in_helper(obj1);
17570 if (arg2 == NULL) SWIG_fail;
17571 temp2 = true;
17572 }
17573 if (obj2) {
17574 {
17575 arg3 = (double)(SWIG_As_double(obj2));
17576 if (SWIG_arg_fail(3)) SWIG_fail;
17577 }
17578 }
17579 {
17580 PyThreadState* __tstate = wxPyBeginAllowThreads();
17581 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17582
17583 wxPyEndAllowThreads(__tstate);
17584 if (PyErr_Occurred()) SWIG_fail;
17585 }
17586 {
17587 resultobj = SWIG_From_double((double)(result));
17588 }
17589 {
17590 if (temp2)
17591 delete arg2;
17592 }
17593 return resultobj;
17594 fail:
17595 {
17596 if (temp2)
17597 delete arg2;
17598 }
17599 return NULL;
17600 }
17601
17602
17603 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17604 PyObject *resultobj;
17605 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17606 wxString *arg2 = 0 ;
17607 bool arg3 = (bool) false ;
17608 bool result;
17609 bool temp2 = false ;
17610 PyObject * obj0 = 0 ;
17611 PyObject * obj1 = 0 ;
17612 PyObject * obj2 = 0 ;
17613 char *kwnames[] = {
17614 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17615 };
17616
17617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17619 if (SWIG_arg_fail(1)) SWIG_fail;
17620 {
17621 arg2 = wxString_in_helper(obj1);
17622 if (arg2 == NULL) SWIG_fail;
17623 temp2 = true;
17624 }
17625 if (obj2) {
17626 {
17627 arg3 = (bool)(SWIG_As_bool(obj2));
17628 if (SWIG_arg_fail(3)) SWIG_fail;
17629 }
17630 }
17631 {
17632 PyThreadState* __tstate = wxPyBeginAllowThreads();
17633 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17634
17635 wxPyEndAllowThreads(__tstate);
17636 if (PyErr_Occurred()) SWIG_fail;
17637 }
17638 {
17639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17640 }
17641 {
17642 if (temp2)
17643 delete arg2;
17644 }
17645 return resultobj;
17646 fail:
17647 {
17648 if (temp2)
17649 delete arg2;
17650 }
17651 return NULL;
17652 }
17653
17654
17655 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17656 PyObject *resultobj;
17657 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17658 wxString *arg2 = 0 ;
17659 wxString *arg3 = 0 ;
17660 bool result;
17661 bool temp2 = false ;
17662 bool temp3 = false ;
17663 PyObject * obj0 = 0 ;
17664 PyObject * obj1 = 0 ;
17665 PyObject * obj2 = 0 ;
17666 char *kwnames[] = {
17667 (char *) "self",(char *) "key",(char *) "value", NULL
17668 };
17669
17670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17672 if (SWIG_arg_fail(1)) SWIG_fail;
17673 {
17674 arg2 = wxString_in_helper(obj1);
17675 if (arg2 == NULL) SWIG_fail;
17676 temp2 = true;
17677 }
17678 {
17679 arg3 = wxString_in_helper(obj2);
17680 if (arg3 == NULL) SWIG_fail;
17681 temp3 = true;
17682 }
17683 {
17684 PyThreadState* __tstate = wxPyBeginAllowThreads();
17685 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17686
17687 wxPyEndAllowThreads(__tstate);
17688 if (PyErr_Occurred()) SWIG_fail;
17689 }
17690 {
17691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17692 }
17693 {
17694 if (temp2)
17695 delete arg2;
17696 }
17697 {
17698 if (temp3)
17699 delete arg3;
17700 }
17701 return resultobj;
17702 fail:
17703 {
17704 if (temp2)
17705 delete arg2;
17706 }
17707 {
17708 if (temp3)
17709 delete arg3;
17710 }
17711 return NULL;
17712 }
17713
17714
17715 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17716 PyObject *resultobj;
17717 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17718 wxString *arg2 = 0 ;
17719 long arg3 ;
17720 bool result;
17721 bool temp2 = false ;
17722 PyObject * obj0 = 0 ;
17723 PyObject * obj1 = 0 ;
17724 PyObject * obj2 = 0 ;
17725 char *kwnames[] = {
17726 (char *) "self",(char *) "key",(char *) "value", NULL
17727 };
17728
17729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17731 if (SWIG_arg_fail(1)) SWIG_fail;
17732 {
17733 arg2 = wxString_in_helper(obj1);
17734 if (arg2 == NULL) SWIG_fail;
17735 temp2 = true;
17736 }
17737 {
17738 arg3 = (long)(SWIG_As_long(obj2));
17739 if (SWIG_arg_fail(3)) SWIG_fail;
17740 }
17741 {
17742 PyThreadState* __tstate = wxPyBeginAllowThreads();
17743 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17744
17745 wxPyEndAllowThreads(__tstate);
17746 if (PyErr_Occurred()) SWIG_fail;
17747 }
17748 {
17749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17750 }
17751 {
17752 if (temp2)
17753 delete arg2;
17754 }
17755 return resultobj;
17756 fail:
17757 {
17758 if (temp2)
17759 delete arg2;
17760 }
17761 return NULL;
17762 }
17763
17764
17765 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17766 PyObject *resultobj;
17767 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17768 wxString *arg2 = 0 ;
17769 double arg3 ;
17770 bool result;
17771 bool temp2 = false ;
17772 PyObject * obj0 = 0 ;
17773 PyObject * obj1 = 0 ;
17774 PyObject * obj2 = 0 ;
17775 char *kwnames[] = {
17776 (char *) "self",(char *) "key",(char *) "value", NULL
17777 };
17778
17779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17781 if (SWIG_arg_fail(1)) SWIG_fail;
17782 {
17783 arg2 = wxString_in_helper(obj1);
17784 if (arg2 == NULL) SWIG_fail;
17785 temp2 = true;
17786 }
17787 {
17788 arg3 = (double)(SWIG_As_double(obj2));
17789 if (SWIG_arg_fail(3)) SWIG_fail;
17790 }
17791 {
17792 PyThreadState* __tstate = wxPyBeginAllowThreads();
17793 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17794
17795 wxPyEndAllowThreads(__tstate);
17796 if (PyErr_Occurred()) SWIG_fail;
17797 }
17798 {
17799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17800 }
17801 {
17802 if (temp2)
17803 delete arg2;
17804 }
17805 return resultobj;
17806 fail:
17807 {
17808 if (temp2)
17809 delete arg2;
17810 }
17811 return NULL;
17812 }
17813
17814
17815 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17816 PyObject *resultobj;
17817 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17818 wxString *arg2 = 0 ;
17819 bool arg3 ;
17820 bool result;
17821 bool temp2 = false ;
17822 PyObject * obj0 = 0 ;
17823 PyObject * obj1 = 0 ;
17824 PyObject * obj2 = 0 ;
17825 char *kwnames[] = {
17826 (char *) "self",(char *) "key",(char *) "value", NULL
17827 };
17828
17829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17831 if (SWIG_arg_fail(1)) SWIG_fail;
17832 {
17833 arg2 = wxString_in_helper(obj1);
17834 if (arg2 == NULL) SWIG_fail;
17835 temp2 = true;
17836 }
17837 {
17838 arg3 = (bool)(SWIG_As_bool(obj2));
17839 if (SWIG_arg_fail(3)) SWIG_fail;
17840 }
17841 {
17842 PyThreadState* __tstate = wxPyBeginAllowThreads();
17843 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17844
17845 wxPyEndAllowThreads(__tstate);
17846 if (PyErr_Occurred()) SWIG_fail;
17847 }
17848 {
17849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17850 }
17851 {
17852 if (temp2)
17853 delete arg2;
17854 }
17855 return resultobj;
17856 fail:
17857 {
17858 if (temp2)
17859 delete arg2;
17860 }
17861 return NULL;
17862 }
17863
17864
17865 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17866 PyObject *resultobj;
17867 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17868 bool arg2 = (bool) false ;
17869 bool result;
17870 PyObject * obj0 = 0 ;
17871 PyObject * obj1 = 0 ;
17872 char *kwnames[] = {
17873 (char *) "self",(char *) "currentOnly", NULL
17874 };
17875
17876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17878 if (SWIG_arg_fail(1)) SWIG_fail;
17879 if (obj1) {
17880 {
17881 arg2 = (bool)(SWIG_As_bool(obj1));
17882 if (SWIG_arg_fail(2)) SWIG_fail;
17883 }
17884 }
17885 {
17886 PyThreadState* __tstate = wxPyBeginAllowThreads();
17887 result = (bool)(arg1)->Flush(arg2);
17888
17889 wxPyEndAllowThreads(__tstate);
17890 if (PyErr_Occurred()) SWIG_fail;
17891 }
17892 {
17893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17894 }
17895 return resultobj;
17896 fail:
17897 return NULL;
17898 }
17899
17900
17901 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17902 PyObject *resultobj;
17903 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17904 wxString *arg2 = 0 ;
17905 wxString *arg3 = 0 ;
17906 bool result;
17907 bool temp2 = false ;
17908 bool temp3 = false ;
17909 PyObject * obj0 = 0 ;
17910 PyObject * obj1 = 0 ;
17911 PyObject * obj2 = 0 ;
17912 char *kwnames[] = {
17913 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17914 };
17915
17916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17918 if (SWIG_arg_fail(1)) SWIG_fail;
17919 {
17920 arg2 = wxString_in_helper(obj1);
17921 if (arg2 == NULL) SWIG_fail;
17922 temp2 = true;
17923 }
17924 {
17925 arg3 = wxString_in_helper(obj2);
17926 if (arg3 == NULL) SWIG_fail;
17927 temp3 = true;
17928 }
17929 {
17930 PyThreadState* __tstate = wxPyBeginAllowThreads();
17931 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17932
17933 wxPyEndAllowThreads(__tstate);
17934 if (PyErr_Occurred()) SWIG_fail;
17935 }
17936 {
17937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17938 }
17939 {
17940 if (temp2)
17941 delete arg2;
17942 }
17943 {
17944 if (temp3)
17945 delete arg3;
17946 }
17947 return resultobj;
17948 fail:
17949 {
17950 if (temp2)
17951 delete arg2;
17952 }
17953 {
17954 if (temp3)
17955 delete arg3;
17956 }
17957 return NULL;
17958 }
17959
17960
17961 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17962 PyObject *resultobj;
17963 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17964 wxString *arg2 = 0 ;
17965 wxString *arg3 = 0 ;
17966 bool result;
17967 bool temp2 = false ;
17968 bool temp3 = false ;
17969 PyObject * obj0 = 0 ;
17970 PyObject * obj1 = 0 ;
17971 PyObject * obj2 = 0 ;
17972 char *kwnames[] = {
17973 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17974 };
17975
17976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17978 if (SWIG_arg_fail(1)) SWIG_fail;
17979 {
17980 arg2 = wxString_in_helper(obj1);
17981 if (arg2 == NULL) SWIG_fail;
17982 temp2 = true;
17983 }
17984 {
17985 arg3 = wxString_in_helper(obj2);
17986 if (arg3 == NULL) SWIG_fail;
17987 temp3 = true;
17988 }
17989 {
17990 PyThreadState* __tstate = wxPyBeginAllowThreads();
17991 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17992
17993 wxPyEndAllowThreads(__tstate);
17994 if (PyErr_Occurred()) SWIG_fail;
17995 }
17996 {
17997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17998 }
17999 {
18000 if (temp2)
18001 delete arg2;
18002 }
18003 {
18004 if (temp3)
18005 delete arg3;
18006 }
18007 return resultobj;
18008 fail:
18009 {
18010 if (temp2)
18011 delete arg2;
18012 }
18013 {
18014 if (temp3)
18015 delete arg3;
18016 }
18017 return NULL;
18018 }
18019
18020
18021 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18022 PyObject *resultobj;
18023 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18024 wxString *arg2 = 0 ;
18025 bool arg3 = (bool) true ;
18026 bool result;
18027 bool temp2 = false ;
18028 PyObject * obj0 = 0 ;
18029 PyObject * obj1 = 0 ;
18030 PyObject * obj2 = 0 ;
18031 char *kwnames[] = {
18032 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18033 };
18034
18035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18037 if (SWIG_arg_fail(1)) SWIG_fail;
18038 {
18039 arg2 = wxString_in_helper(obj1);
18040 if (arg2 == NULL) SWIG_fail;
18041 temp2 = true;
18042 }
18043 if (obj2) {
18044 {
18045 arg3 = (bool)(SWIG_As_bool(obj2));
18046 if (SWIG_arg_fail(3)) SWIG_fail;
18047 }
18048 }
18049 {
18050 PyThreadState* __tstate = wxPyBeginAllowThreads();
18051 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18052
18053 wxPyEndAllowThreads(__tstate);
18054 if (PyErr_Occurred()) SWIG_fail;
18055 }
18056 {
18057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18058 }
18059 {
18060 if (temp2)
18061 delete arg2;
18062 }
18063 return resultobj;
18064 fail:
18065 {
18066 if (temp2)
18067 delete arg2;
18068 }
18069 return NULL;
18070 }
18071
18072
18073 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18074 PyObject *resultobj;
18075 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18076 wxString *arg2 = 0 ;
18077 bool result;
18078 bool temp2 = false ;
18079 PyObject * obj0 = 0 ;
18080 PyObject * obj1 = 0 ;
18081 char *kwnames[] = {
18082 (char *) "self",(char *) "key", NULL
18083 };
18084
18085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18087 if (SWIG_arg_fail(1)) SWIG_fail;
18088 {
18089 arg2 = wxString_in_helper(obj1);
18090 if (arg2 == NULL) SWIG_fail;
18091 temp2 = true;
18092 }
18093 {
18094 PyThreadState* __tstate = wxPyBeginAllowThreads();
18095 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18096
18097 wxPyEndAllowThreads(__tstate);
18098 if (PyErr_Occurred()) SWIG_fail;
18099 }
18100 {
18101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18102 }
18103 {
18104 if (temp2)
18105 delete arg2;
18106 }
18107 return resultobj;
18108 fail:
18109 {
18110 if (temp2)
18111 delete arg2;
18112 }
18113 return NULL;
18114 }
18115
18116
18117 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18118 PyObject *resultobj;
18119 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18120 bool result;
18121 PyObject * obj0 = 0 ;
18122 char *kwnames[] = {
18123 (char *) "self", NULL
18124 };
18125
18126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18128 if (SWIG_arg_fail(1)) SWIG_fail;
18129 {
18130 PyThreadState* __tstate = wxPyBeginAllowThreads();
18131 result = (bool)(arg1)->DeleteAll();
18132
18133 wxPyEndAllowThreads(__tstate);
18134 if (PyErr_Occurred()) SWIG_fail;
18135 }
18136 {
18137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18138 }
18139 return resultobj;
18140 fail:
18141 return NULL;
18142 }
18143
18144
18145 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18146 PyObject *resultobj;
18147 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18148 bool arg2 = (bool) true ;
18149 PyObject * obj0 = 0 ;
18150 PyObject * obj1 = 0 ;
18151 char *kwnames[] = {
18152 (char *) "self",(char *) "doIt", NULL
18153 };
18154
18155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18157 if (SWIG_arg_fail(1)) SWIG_fail;
18158 if (obj1) {
18159 {
18160 arg2 = (bool)(SWIG_As_bool(obj1));
18161 if (SWIG_arg_fail(2)) SWIG_fail;
18162 }
18163 }
18164 {
18165 PyThreadState* __tstate = wxPyBeginAllowThreads();
18166 (arg1)->SetExpandEnvVars(arg2);
18167
18168 wxPyEndAllowThreads(__tstate);
18169 if (PyErr_Occurred()) SWIG_fail;
18170 }
18171 Py_INCREF(Py_None); resultobj = Py_None;
18172 return resultobj;
18173 fail:
18174 return NULL;
18175 }
18176
18177
18178 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18179 PyObject *resultobj;
18180 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18181 bool result;
18182 PyObject * obj0 = 0 ;
18183 char *kwnames[] = {
18184 (char *) "self", NULL
18185 };
18186
18187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18189 if (SWIG_arg_fail(1)) SWIG_fail;
18190 {
18191 PyThreadState* __tstate = wxPyBeginAllowThreads();
18192 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18193
18194 wxPyEndAllowThreads(__tstate);
18195 if (PyErr_Occurred()) SWIG_fail;
18196 }
18197 {
18198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18199 }
18200 return resultobj;
18201 fail:
18202 return NULL;
18203 }
18204
18205
18206 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18207 PyObject *resultobj;
18208 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18209 bool arg2 = (bool) true ;
18210 PyObject * obj0 = 0 ;
18211 PyObject * obj1 = 0 ;
18212 char *kwnames[] = {
18213 (char *) "self",(char *) "doIt", NULL
18214 };
18215
18216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18218 if (SWIG_arg_fail(1)) SWIG_fail;
18219 if (obj1) {
18220 {
18221 arg2 = (bool)(SWIG_As_bool(obj1));
18222 if (SWIG_arg_fail(2)) SWIG_fail;
18223 }
18224 }
18225 {
18226 PyThreadState* __tstate = wxPyBeginAllowThreads();
18227 (arg1)->SetRecordDefaults(arg2);
18228
18229 wxPyEndAllowThreads(__tstate);
18230 if (PyErr_Occurred()) SWIG_fail;
18231 }
18232 Py_INCREF(Py_None); resultobj = Py_None;
18233 return resultobj;
18234 fail:
18235 return NULL;
18236 }
18237
18238
18239 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18240 PyObject *resultobj;
18241 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18242 bool result;
18243 PyObject * obj0 = 0 ;
18244 char *kwnames[] = {
18245 (char *) "self", NULL
18246 };
18247
18248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18250 if (SWIG_arg_fail(1)) SWIG_fail;
18251 {
18252 PyThreadState* __tstate = wxPyBeginAllowThreads();
18253 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18254
18255 wxPyEndAllowThreads(__tstate);
18256 if (PyErr_Occurred()) SWIG_fail;
18257 }
18258 {
18259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18260 }
18261 return resultobj;
18262 fail:
18263 return NULL;
18264 }
18265
18266
18267 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18268 PyObject *resultobj;
18269 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18270 wxString *arg2 = 0 ;
18271 wxString result;
18272 bool temp2 = false ;
18273 PyObject * obj0 = 0 ;
18274 PyObject * obj1 = 0 ;
18275 char *kwnames[] = {
18276 (char *) "self",(char *) "str", NULL
18277 };
18278
18279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18281 if (SWIG_arg_fail(1)) SWIG_fail;
18282 {
18283 arg2 = wxString_in_helper(obj1);
18284 if (arg2 == NULL) SWIG_fail;
18285 temp2 = true;
18286 }
18287 {
18288 PyThreadState* __tstate = wxPyBeginAllowThreads();
18289 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18290
18291 wxPyEndAllowThreads(__tstate);
18292 if (PyErr_Occurred()) SWIG_fail;
18293 }
18294 {
18295 #if wxUSE_UNICODE
18296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18297 #else
18298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18299 #endif
18300 }
18301 {
18302 if (temp2)
18303 delete arg2;
18304 }
18305 return resultobj;
18306 fail:
18307 {
18308 if (temp2)
18309 delete arg2;
18310 }
18311 return NULL;
18312 }
18313
18314
18315 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18316 PyObject *resultobj;
18317 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18318 wxString result;
18319 PyObject * obj0 = 0 ;
18320 char *kwnames[] = {
18321 (char *) "self", NULL
18322 };
18323
18324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18326 if (SWIG_arg_fail(1)) SWIG_fail;
18327 {
18328 PyThreadState* __tstate = wxPyBeginAllowThreads();
18329 result = ((wxConfigBase const *)arg1)->GetAppName();
18330
18331 wxPyEndAllowThreads(__tstate);
18332 if (PyErr_Occurred()) SWIG_fail;
18333 }
18334 {
18335 #if wxUSE_UNICODE
18336 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18337 #else
18338 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18339 #endif
18340 }
18341 return resultobj;
18342 fail:
18343 return NULL;
18344 }
18345
18346
18347 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18348 PyObject *resultobj;
18349 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18350 wxString result;
18351 PyObject * obj0 = 0 ;
18352 char *kwnames[] = {
18353 (char *) "self", NULL
18354 };
18355
18356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18358 if (SWIG_arg_fail(1)) SWIG_fail;
18359 {
18360 PyThreadState* __tstate = wxPyBeginAllowThreads();
18361 result = ((wxConfigBase const *)arg1)->GetVendorName();
18362
18363 wxPyEndAllowThreads(__tstate);
18364 if (PyErr_Occurred()) SWIG_fail;
18365 }
18366 {
18367 #if wxUSE_UNICODE
18368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18369 #else
18370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18371 #endif
18372 }
18373 return resultobj;
18374 fail:
18375 return NULL;
18376 }
18377
18378
18379 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18380 PyObject *resultobj;
18381 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18382 wxString *arg2 = 0 ;
18383 bool temp2 = false ;
18384 PyObject * obj0 = 0 ;
18385 PyObject * obj1 = 0 ;
18386 char *kwnames[] = {
18387 (char *) "self",(char *) "appName", NULL
18388 };
18389
18390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18392 if (SWIG_arg_fail(1)) SWIG_fail;
18393 {
18394 arg2 = wxString_in_helper(obj1);
18395 if (arg2 == NULL) SWIG_fail;
18396 temp2 = true;
18397 }
18398 {
18399 PyThreadState* __tstate = wxPyBeginAllowThreads();
18400 (arg1)->SetAppName((wxString const &)*arg2);
18401
18402 wxPyEndAllowThreads(__tstate);
18403 if (PyErr_Occurred()) SWIG_fail;
18404 }
18405 Py_INCREF(Py_None); resultobj = Py_None;
18406 {
18407 if (temp2)
18408 delete arg2;
18409 }
18410 return resultobj;
18411 fail:
18412 {
18413 if (temp2)
18414 delete arg2;
18415 }
18416 return NULL;
18417 }
18418
18419
18420 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18421 PyObject *resultobj;
18422 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18423 wxString *arg2 = 0 ;
18424 bool temp2 = false ;
18425 PyObject * obj0 = 0 ;
18426 PyObject * obj1 = 0 ;
18427 char *kwnames[] = {
18428 (char *) "self",(char *) "vendorName", NULL
18429 };
18430
18431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18433 if (SWIG_arg_fail(1)) SWIG_fail;
18434 {
18435 arg2 = wxString_in_helper(obj1);
18436 if (arg2 == NULL) SWIG_fail;
18437 temp2 = true;
18438 }
18439 {
18440 PyThreadState* __tstate = wxPyBeginAllowThreads();
18441 (arg1)->SetVendorName((wxString const &)*arg2);
18442
18443 wxPyEndAllowThreads(__tstate);
18444 if (PyErr_Occurred()) SWIG_fail;
18445 }
18446 Py_INCREF(Py_None); resultobj = Py_None;
18447 {
18448 if (temp2)
18449 delete arg2;
18450 }
18451 return resultobj;
18452 fail:
18453 {
18454 if (temp2)
18455 delete arg2;
18456 }
18457 return NULL;
18458 }
18459
18460
18461 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18462 PyObject *resultobj;
18463 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18464 long arg2 ;
18465 PyObject * obj0 = 0 ;
18466 PyObject * obj1 = 0 ;
18467 char *kwnames[] = {
18468 (char *) "self",(char *) "style", NULL
18469 };
18470
18471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18473 if (SWIG_arg_fail(1)) SWIG_fail;
18474 {
18475 arg2 = (long)(SWIG_As_long(obj1));
18476 if (SWIG_arg_fail(2)) SWIG_fail;
18477 }
18478 {
18479 PyThreadState* __tstate = wxPyBeginAllowThreads();
18480 (arg1)->SetStyle(arg2);
18481
18482 wxPyEndAllowThreads(__tstate);
18483 if (PyErr_Occurred()) SWIG_fail;
18484 }
18485 Py_INCREF(Py_None); resultobj = Py_None;
18486 return resultobj;
18487 fail:
18488 return NULL;
18489 }
18490
18491
18492 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18493 PyObject *resultobj;
18494 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18495 long result;
18496 PyObject * obj0 = 0 ;
18497 char *kwnames[] = {
18498 (char *) "self", NULL
18499 };
18500
18501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18503 if (SWIG_arg_fail(1)) SWIG_fail;
18504 {
18505 PyThreadState* __tstate = wxPyBeginAllowThreads();
18506 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18507
18508 wxPyEndAllowThreads(__tstate);
18509 if (PyErr_Occurred()) SWIG_fail;
18510 }
18511 {
18512 resultobj = SWIG_From_long((long)(result));
18513 }
18514 return resultobj;
18515 fail:
18516 return NULL;
18517 }
18518
18519
18520 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18521 PyObject *obj;
18522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18523 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18524 Py_INCREF(obj);
18525 return Py_BuildValue((char *)"");
18526 }
18527 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18528 PyObject *resultobj;
18529 wxString const &arg1_defvalue = wxPyEmptyString ;
18530 wxString *arg1 = (wxString *) &arg1_defvalue ;
18531 wxString const &arg2_defvalue = wxPyEmptyString ;
18532 wxString *arg2 = (wxString *) &arg2_defvalue ;
18533 wxString const &arg3_defvalue = wxPyEmptyString ;
18534 wxString *arg3 = (wxString *) &arg3_defvalue ;
18535 wxString const &arg4_defvalue = wxPyEmptyString ;
18536 wxString *arg4 = (wxString *) &arg4_defvalue ;
18537 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18538 wxConfig *result;
18539 bool temp1 = false ;
18540 bool temp2 = false ;
18541 bool temp3 = false ;
18542 bool temp4 = false ;
18543 PyObject * obj0 = 0 ;
18544 PyObject * obj1 = 0 ;
18545 PyObject * obj2 = 0 ;
18546 PyObject * obj3 = 0 ;
18547 PyObject * obj4 = 0 ;
18548 char *kwnames[] = {
18549 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18550 };
18551
18552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18553 if (obj0) {
18554 {
18555 arg1 = wxString_in_helper(obj0);
18556 if (arg1 == NULL) SWIG_fail;
18557 temp1 = true;
18558 }
18559 }
18560 if (obj1) {
18561 {
18562 arg2 = wxString_in_helper(obj1);
18563 if (arg2 == NULL) SWIG_fail;
18564 temp2 = true;
18565 }
18566 }
18567 if (obj2) {
18568 {
18569 arg3 = wxString_in_helper(obj2);
18570 if (arg3 == NULL) SWIG_fail;
18571 temp3 = true;
18572 }
18573 }
18574 if (obj3) {
18575 {
18576 arg4 = wxString_in_helper(obj3);
18577 if (arg4 == NULL) SWIG_fail;
18578 temp4 = true;
18579 }
18580 }
18581 if (obj4) {
18582 {
18583 arg5 = (long)(SWIG_As_long(obj4));
18584 if (SWIG_arg_fail(5)) SWIG_fail;
18585 }
18586 }
18587 {
18588 PyThreadState* __tstate = wxPyBeginAllowThreads();
18589 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18590
18591 wxPyEndAllowThreads(__tstate);
18592 if (PyErr_Occurred()) SWIG_fail;
18593 }
18594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18595 {
18596 if (temp1)
18597 delete arg1;
18598 }
18599 {
18600 if (temp2)
18601 delete arg2;
18602 }
18603 {
18604 if (temp3)
18605 delete arg3;
18606 }
18607 {
18608 if (temp4)
18609 delete arg4;
18610 }
18611 return resultobj;
18612 fail:
18613 {
18614 if (temp1)
18615 delete arg1;
18616 }
18617 {
18618 if (temp2)
18619 delete arg2;
18620 }
18621 {
18622 if (temp3)
18623 delete arg3;
18624 }
18625 {
18626 if (temp4)
18627 delete arg4;
18628 }
18629 return NULL;
18630 }
18631
18632
18633 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18634 PyObject *resultobj;
18635 wxConfig *arg1 = (wxConfig *) 0 ;
18636 PyObject * obj0 = 0 ;
18637 char *kwnames[] = {
18638 (char *) "self", NULL
18639 };
18640
18641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18643 if (SWIG_arg_fail(1)) SWIG_fail;
18644 {
18645 PyThreadState* __tstate = wxPyBeginAllowThreads();
18646 delete arg1;
18647
18648 wxPyEndAllowThreads(__tstate);
18649 if (PyErr_Occurred()) SWIG_fail;
18650 }
18651 Py_INCREF(Py_None); resultobj = Py_None;
18652 return resultobj;
18653 fail:
18654 return NULL;
18655 }
18656
18657
18658 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18659 PyObject *obj;
18660 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18661 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18662 Py_INCREF(obj);
18663 return Py_BuildValue((char *)"");
18664 }
18665 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18666 PyObject *resultobj;
18667 wxString const &arg1_defvalue = wxPyEmptyString ;
18668 wxString *arg1 = (wxString *) &arg1_defvalue ;
18669 wxString const &arg2_defvalue = wxPyEmptyString ;
18670 wxString *arg2 = (wxString *) &arg2_defvalue ;
18671 wxString const &arg3_defvalue = wxPyEmptyString ;
18672 wxString *arg3 = (wxString *) &arg3_defvalue ;
18673 wxString const &arg4_defvalue = wxPyEmptyString ;
18674 wxString *arg4 = (wxString *) &arg4_defvalue ;
18675 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18676 wxFileConfig *result;
18677 bool temp1 = false ;
18678 bool temp2 = false ;
18679 bool temp3 = false ;
18680 bool temp4 = false ;
18681 PyObject * obj0 = 0 ;
18682 PyObject * obj1 = 0 ;
18683 PyObject * obj2 = 0 ;
18684 PyObject * obj3 = 0 ;
18685 PyObject * obj4 = 0 ;
18686 char *kwnames[] = {
18687 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18688 };
18689
18690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18691 if (obj0) {
18692 {
18693 arg1 = wxString_in_helper(obj0);
18694 if (arg1 == NULL) SWIG_fail;
18695 temp1 = true;
18696 }
18697 }
18698 if (obj1) {
18699 {
18700 arg2 = wxString_in_helper(obj1);
18701 if (arg2 == NULL) SWIG_fail;
18702 temp2 = true;
18703 }
18704 }
18705 if (obj2) {
18706 {
18707 arg3 = wxString_in_helper(obj2);
18708 if (arg3 == NULL) SWIG_fail;
18709 temp3 = true;
18710 }
18711 }
18712 if (obj3) {
18713 {
18714 arg4 = wxString_in_helper(obj3);
18715 if (arg4 == NULL) SWIG_fail;
18716 temp4 = true;
18717 }
18718 }
18719 if (obj4) {
18720 {
18721 arg5 = (long)(SWIG_As_long(obj4));
18722 if (SWIG_arg_fail(5)) SWIG_fail;
18723 }
18724 }
18725 {
18726 PyThreadState* __tstate = wxPyBeginAllowThreads();
18727 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18728
18729 wxPyEndAllowThreads(__tstate);
18730 if (PyErr_Occurred()) SWIG_fail;
18731 }
18732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18733 {
18734 if (temp1)
18735 delete arg1;
18736 }
18737 {
18738 if (temp2)
18739 delete arg2;
18740 }
18741 {
18742 if (temp3)
18743 delete arg3;
18744 }
18745 {
18746 if (temp4)
18747 delete arg4;
18748 }
18749 return resultobj;
18750 fail:
18751 {
18752 if (temp1)
18753 delete arg1;
18754 }
18755 {
18756 if (temp2)
18757 delete arg2;
18758 }
18759 {
18760 if (temp3)
18761 delete arg3;
18762 }
18763 {
18764 if (temp4)
18765 delete arg4;
18766 }
18767 return NULL;
18768 }
18769
18770
18771 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18772 PyObject *resultobj;
18773 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18774 PyObject * obj0 = 0 ;
18775 char *kwnames[] = {
18776 (char *) "self", NULL
18777 };
18778
18779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18781 if (SWIG_arg_fail(1)) SWIG_fail;
18782 {
18783 PyThreadState* __tstate = wxPyBeginAllowThreads();
18784 delete arg1;
18785
18786 wxPyEndAllowThreads(__tstate);
18787 if (PyErr_Occurred()) SWIG_fail;
18788 }
18789 Py_INCREF(Py_None); resultobj = Py_None;
18790 return resultobj;
18791 fail:
18792 return NULL;
18793 }
18794
18795
18796 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18797 PyObject *obj;
18798 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18799 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18800 Py_INCREF(obj);
18801 return Py_BuildValue((char *)"");
18802 }
18803 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18804 PyObject *resultobj;
18805 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18806 wxString *arg2 = 0 ;
18807 wxConfigPathChanger *result;
18808 bool temp2 = false ;
18809 PyObject * obj0 = 0 ;
18810 PyObject * obj1 = 0 ;
18811 char *kwnames[] = {
18812 (char *) "config",(char *) "entry", NULL
18813 };
18814
18815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18817 if (SWIG_arg_fail(1)) SWIG_fail;
18818 {
18819 arg2 = wxString_in_helper(obj1);
18820 if (arg2 == NULL) SWIG_fail;
18821 temp2 = true;
18822 }
18823 {
18824 PyThreadState* __tstate = wxPyBeginAllowThreads();
18825 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18826
18827 wxPyEndAllowThreads(__tstate);
18828 if (PyErr_Occurred()) SWIG_fail;
18829 }
18830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18831 {
18832 if (temp2)
18833 delete arg2;
18834 }
18835 return resultobj;
18836 fail:
18837 {
18838 if (temp2)
18839 delete arg2;
18840 }
18841 return NULL;
18842 }
18843
18844
18845 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18846 PyObject *resultobj;
18847 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18848 PyObject * obj0 = 0 ;
18849 char *kwnames[] = {
18850 (char *) "self", NULL
18851 };
18852
18853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18855 if (SWIG_arg_fail(1)) SWIG_fail;
18856 {
18857 PyThreadState* __tstate = wxPyBeginAllowThreads();
18858 delete arg1;
18859
18860 wxPyEndAllowThreads(__tstate);
18861 if (PyErr_Occurred()) SWIG_fail;
18862 }
18863 Py_INCREF(Py_None); resultobj = Py_None;
18864 return resultobj;
18865 fail:
18866 return NULL;
18867 }
18868
18869
18870 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18871 PyObject *resultobj;
18872 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18873 wxString *result;
18874 PyObject * obj0 = 0 ;
18875 char *kwnames[] = {
18876 (char *) "self", NULL
18877 };
18878
18879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18881 if (SWIG_arg_fail(1)) SWIG_fail;
18882 {
18883 PyThreadState* __tstate = wxPyBeginAllowThreads();
18884 {
18885 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18886 result = (wxString *) &_result_ref;
18887 }
18888
18889 wxPyEndAllowThreads(__tstate);
18890 if (PyErr_Occurred()) SWIG_fail;
18891 }
18892 {
18893 #if wxUSE_UNICODE
18894 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18895 #else
18896 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18897 #endif
18898 }
18899 return resultobj;
18900 fail:
18901 return NULL;
18902 }
18903
18904
18905 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18906 PyObject *obj;
18907 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18908 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18909 Py_INCREF(obj);
18910 return Py_BuildValue((char *)"");
18911 }
18912 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18913 PyObject *resultobj;
18914 wxString *arg1 = 0 ;
18915 wxString result;
18916 bool temp1 = false ;
18917 PyObject * obj0 = 0 ;
18918 char *kwnames[] = {
18919 (char *) "sz", NULL
18920 };
18921
18922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18923 {
18924 arg1 = wxString_in_helper(obj0);
18925 if (arg1 == NULL) SWIG_fail;
18926 temp1 = true;
18927 }
18928 {
18929 PyThreadState* __tstate = wxPyBeginAllowThreads();
18930 result = wxExpandEnvVars((wxString const &)*arg1);
18931
18932 wxPyEndAllowThreads(__tstate);
18933 if (PyErr_Occurred()) SWIG_fail;
18934 }
18935 {
18936 #if wxUSE_UNICODE
18937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18938 #else
18939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18940 #endif
18941 }
18942 {
18943 if (temp1)
18944 delete arg1;
18945 }
18946 return resultobj;
18947 fail:
18948 {
18949 if (temp1)
18950 delete arg1;
18951 }
18952 return NULL;
18953 }
18954
18955
18956 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18957 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18958 return 1;
18959 }
18960
18961
18962 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18963 PyObject *pyobj;
18964
18965 {
18966 #if wxUSE_UNICODE
18967 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18968 #else
18969 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18970 #endif
18971 }
18972 return pyobj;
18973 }
18974
18975
18976 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18977 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18978 return 1;
18979 }
18980
18981
18982 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18983 PyObject *pyobj;
18984
18985 {
18986 #if wxUSE_UNICODE
18987 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18988 #else
18989 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18990 #endif
18991 }
18992 return pyobj;
18993 }
18994
18995
18996 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18997 PyObject *resultobj;
18998 wxDateTime::Country arg1 ;
18999 PyObject * obj0 = 0 ;
19000 char *kwnames[] = {
19001 (char *) "country", NULL
19002 };
19003
19004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19005 {
19006 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19007 if (SWIG_arg_fail(1)) SWIG_fail;
19008 }
19009 {
19010 PyThreadState* __tstate = wxPyBeginAllowThreads();
19011 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19012
19013 wxPyEndAllowThreads(__tstate);
19014 if (PyErr_Occurred()) SWIG_fail;
19015 }
19016 Py_INCREF(Py_None); resultobj = Py_None;
19017 return resultobj;
19018 fail:
19019 return NULL;
19020 }
19021
19022
19023 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19024 PyObject *resultobj;
19025 wxDateTime::Country result;
19026 char *kwnames[] = {
19027 NULL
19028 };
19029
19030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19031 {
19032 PyThreadState* __tstate = wxPyBeginAllowThreads();
19033 result = (wxDateTime::Country)wxDateTime::GetCountry();
19034
19035 wxPyEndAllowThreads(__tstate);
19036 if (PyErr_Occurred()) SWIG_fail;
19037 }
19038 resultobj = SWIG_From_int((result));
19039 return resultobj;
19040 fail:
19041 return NULL;
19042 }
19043
19044
19045 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19046 PyObject *resultobj;
19047 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19048 bool result;
19049 PyObject * obj0 = 0 ;
19050 char *kwnames[] = {
19051 (char *) "country", NULL
19052 };
19053
19054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19055 if (obj0) {
19056 {
19057 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19058 if (SWIG_arg_fail(1)) SWIG_fail;
19059 }
19060 }
19061 {
19062 PyThreadState* __tstate = wxPyBeginAllowThreads();
19063 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19064
19065 wxPyEndAllowThreads(__tstate);
19066 if (PyErr_Occurred()) SWIG_fail;
19067 }
19068 {
19069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19070 }
19071 return resultobj;
19072 fail:
19073 return NULL;
19074 }
19075
19076
19077 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19078 PyObject *resultobj;
19079 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19080 int result;
19081 PyObject * obj0 = 0 ;
19082 char *kwnames[] = {
19083 (char *) "cal", NULL
19084 };
19085
19086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19087 if (obj0) {
19088 {
19089 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19090 if (SWIG_arg_fail(1)) SWIG_fail;
19091 }
19092 }
19093 {
19094 PyThreadState* __tstate = wxPyBeginAllowThreads();
19095 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19096
19097 wxPyEndAllowThreads(__tstate);
19098 if (PyErr_Occurred()) SWIG_fail;
19099 }
19100 {
19101 resultobj = SWIG_From_int((int)(result));
19102 }
19103 return resultobj;
19104 fail:
19105 return NULL;
19106 }
19107
19108
19109 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19110 PyObject *resultobj;
19111 int arg1 ;
19112 int result;
19113 PyObject * obj0 = 0 ;
19114 char *kwnames[] = {
19115 (char *) "year", NULL
19116 };
19117
19118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19119 {
19120 arg1 = (int)(SWIG_As_int(obj0));
19121 if (SWIG_arg_fail(1)) SWIG_fail;
19122 }
19123 {
19124 PyThreadState* __tstate = wxPyBeginAllowThreads();
19125 result = (int)wxDateTime::ConvertYearToBC(arg1);
19126
19127 wxPyEndAllowThreads(__tstate);
19128 if (PyErr_Occurred()) SWIG_fail;
19129 }
19130 {
19131 resultobj = SWIG_From_int((int)(result));
19132 }
19133 return resultobj;
19134 fail:
19135 return NULL;
19136 }
19137
19138
19139 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19140 PyObject *resultobj;
19141 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19142 wxDateTime::Month result;
19143 PyObject * obj0 = 0 ;
19144 char *kwnames[] = {
19145 (char *) "cal", NULL
19146 };
19147
19148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19149 if (obj0) {
19150 {
19151 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19152 if (SWIG_arg_fail(1)) SWIG_fail;
19153 }
19154 }
19155 {
19156 PyThreadState* __tstate = wxPyBeginAllowThreads();
19157 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19158
19159 wxPyEndAllowThreads(__tstate);
19160 if (PyErr_Occurred()) SWIG_fail;
19161 }
19162 resultobj = SWIG_From_int((result));
19163 return resultobj;
19164 fail:
19165 return NULL;
19166 }
19167
19168
19169 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19170 PyObject *resultobj;
19171 int arg1 = (int) wxDateTime::Inv_Year ;
19172 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19173 bool result;
19174 PyObject * obj0 = 0 ;
19175 PyObject * obj1 = 0 ;
19176 char *kwnames[] = {
19177 (char *) "year",(char *) "cal", NULL
19178 };
19179
19180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19181 if (obj0) {
19182 {
19183 arg1 = (int)(SWIG_As_int(obj0));
19184 if (SWIG_arg_fail(1)) SWIG_fail;
19185 }
19186 }
19187 if (obj1) {
19188 {
19189 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19190 if (SWIG_arg_fail(2)) SWIG_fail;
19191 }
19192 }
19193 {
19194 PyThreadState* __tstate = wxPyBeginAllowThreads();
19195 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19196
19197 wxPyEndAllowThreads(__tstate);
19198 if (PyErr_Occurred()) SWIG_fail;
19199 }
19200 {
19201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19202 }
19203 return resultobj;
19204 fail:
19205 return NULL;
19206 }
19207
19208
19209 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19210 PyObject *resultobj;
19211 int arg1 = (int) wxDateTime::Inv_Year ;
19212 int result;
19213 PyObject * obj0 = 0 ;
19214 char *kwnames[] = {
19215 (char *) "year", NULL
19216 };
19217
19218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19219 if (obj0) {
19220 {
19221 arg1 = (int)(SWIG_As_int(obj0));
19222 if (SWIG_arg_fail(1)) SWIG_fail;
19223 }
19224 }
19225 {
19226 PyThreadState* __tstate = wxPyBeginAllowThreads();
19227 result = (int)wxDateTime::GetCentury(arg1);
19228
19229 wxPyEndAllowThreads(__tstate);
19230 if (PyErr_Occurred()) SWIG_fail;
19231 }
19232 {
19233 resultobj = SWIG_From_int((int)(result));
19234 }
19235 return resultobj;
19236 fail:
19237 return NULL;
19238 }
19239
19240
19241 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19242 PyObject *resultobj;
19243 int arg1 ;
19244 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19245 int result;
19246 PyObject * obj0 = 0 ;
19247 PyObject * obj1 = 0 ;
19248 char *kwnames[] = {
19249 (char *) "year",(char *) "cal", NULL
19250 };
19251
19252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19253 {
19254 arg1 = (int)(SWIG_As_int(obj0));
19255 if (SWIG_arg_fail(1)) SWIG_fail;
19256 }
19257 if (obj1) {
19258 {
19259 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19260 if (SWIG_arg_fail(2)) SWIG_fail;
19261 }
19262 }
19263 {
19264 PyThreadState* __tstate = wxPyBeginAllowThreads();
19265 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19266
19267 wxPyEndAllowThreads(__tstate);
19268 if (PyErr_Occurred()) SWIG_fail;
19269 }
19270 {
19271 resultobj = SWIG_From_int((int)(result));
19272 }
19273 return resultobj;
19274 fail:
19275 return NULL;
19276 }
19277
19278
19279 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19280 PyObject *resultobj;
19281 wxDateTime::Month arg1 ;
19282 int arg2 = (int) wxDateTime::Inv_Year ;
19283 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19284 int result;
19285 PyObject * obj0 = 0 ;
19286 PyObject * obj1 = 0 ;
19287 PyObject * obj2 = 0 ;
19288 char *kwnames[] = {
19289 (char *) "month",(char *) "year",(char *) "cal", NULL
19290 };
19291
19292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19293 {
19294 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19295 if (SWIG_arg_fail(1)) SWIG_fail;
19296 }
19297 if (obj1) {
19298 {
19299 arg2 = (int)(SWIG_As_int(obj1));
19300 if (SWIG_arg_fail(2)) SWIG_fail;
19301 }
19302 }
19303 if (obj2) {
19304 {
19305 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19306 if (SWIG_arg_fail(3)) SWIG_fail;
19307 }
19308 }
19309 {
19310 PyThreadState* __tstate = wxPyBeginAllowThreads();
19311 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19312
19313 wxPyEndAllowThreads(__tstate);
19314 if (PyErr_Occurred()) SWIG_fail;
19315 }
19316 {
19317 resultobj = SWIG_From_int((int)(result));
19318 }
19319 return resultobj;
19320 fail:
19321 return NULL;
19322 }
19323
19324
19325 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19326 PyObject *resultobj;
19327 wxDateTime::Month arg1 ;
19328 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19329 wxString result;
19330 PyObject * obj0 = 0 ;
19331 PyObject * obj1 = 0 ;
19332 char *kwnames[] = {
19333 (char *) "month",(char *) "flags", NULL
19334 };
19335
19336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19337 {
19338 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19339 if (SWIG_arg_fail(1)) SWIG_fail;
19340 }
19341 if (obj1) {
19342 {
19343 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19344 if (SWIG_arg_fail(2)) SWIG_fail;
19345 }
19346 }
19347 {
19348 PyThreadState* __tstate = wxPyBeginAllowThreads();
19349 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19350
19351 wxPyEndAllowThreads(__tstate);
19352 if (PyErr_Occurred()) SWIG_fail;
19353 }
19354 {
19355 #if wxUSE_UNICODE
19356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19357 #else
19358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19359 #endif
19360 }
19361 return resultobj;
19362 fail:
19363 return NULL;
19364 }
19365
19366
19367 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19368 PyObject *resultobj;
19369 wxDateTime::WeekDay arg1 ;
19370 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19371 wxString result;
19372 PyObject * obj0 = 0 ;
19373 PyObject * obj1 = 0 ;
19374 char *kwnames[] = {
19375 (char *) "weekday",(char *) "flags", NULL
19376 };
19377
19378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19379 {
19380 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19381 if (SWIG_arg_fail(1)) SWIG_fail;
19382 }
19383 if (obj1) {
19384 {
19385 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19386 if (SWIG_arg_fail(2)) SWIG_fail;
19387 }
19388 }
19389 {
19390 PyThreadState* __tstate = wxPyBeginAllowThreads();
19391 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19392
19393 wxPyEndAllowThreads(__tstate);
19394 if (PyErr_Occurred()) SWIG_fail;
19395 }
19396 {
19397 #if wxUSE_UNICODE
19398 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19399 #else
19400 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19401 #endif
19402 }
19403 return resultobj;
19404 fail:
19405 return NULL;
19406 }
19407
19408
19409 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19410 PyObject *resultobj;
19411 PyObject *result;
19412 char *kwnames[] = {
19413 NULL
19414 };
19415
19416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19417 {
19418 PyThreadState* __tstate = wxPyBeginAllowThreads();
19419 result = (PyObject *)DateTime_GetAmPmStrings();
19420
19421 wxPyEndAllowThreads(__tstate);
19422 if (PyErr_Occurred()) SWIG_fail;
19423 }
19424 resultobj = result;
19425 return resultobj;
19426 fail:
19427 return NULL;
19428 }
19429
19430
19431 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19432 PyObject *resultobj;
19433 int arg1 = (int) wxDateTime::Inv_Year ;
19434 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19435 bool result;
19436 PyObject * obj0 = 0 ;
19437 PyObject * obj1 = 0 ;
19438 char *kwnames[] = {
19439 (char *) "year",(char *) "country", NULL
19440 };
19441
19442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19443 if (obj0) {
19444 {
19445 arg1 = (int)(SWIG_As_int(obj0));
19446 if (SWIG_arg_fail(1)) SWIG_fail;
19447 }
19448 }
19449 if (obj1) {
19450 {
19451 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19452 if (SWIG_arg_fail(2)) SWIG_fail;
19453 }
19454 }
19455 {
19456 PyThreadState* __tstate = wxPyBeginAllowThreads();
19457 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19458
19459 wxPyEndAllowThreads(__tstate);
19460 if (PyErr_Occurred()) SWIG_fail;
19461 }
19462 {
19463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19464 }
19465 return resultobj;
19466 fail:
19467 return NULL;
19468 }
19469
19470
19471 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19472 PyObject *resultobj;
19473 int arg1 = (int) wxDateTime::Inv_Year ;
19474 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19475 wxDateTime result;
19476 PyObject * obj0 = 0 ;
19477 PyObject * obj1 = 0 ;
19478 char *kwnames[] = {
19479 (char *) "year",(char *) "country", NULL
19480 };
19481
19482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19483 if (obj0) {
19484 {
19485 arg1 = (int)(SWIG_As_int(obj0));
19486 if (SWIG_arg_fail(1)) SWIG_fail;
19487 }
19488 }
19489 if (obj1) {
19490 {
19491 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19492 if (SWIG_arg_fail(2)) SWIG_fail;
19493 }
19494 }
19495 {
19496 PyThreadState* __tstate = wxPyBeginAllowThreads();
19497 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19498
19499 wxPyEndAllowThreads(__tstate);
19500 if (PyErr_Occurred()) SWIG_fail;
19501 }
19502 {
19503 wxDateTime * resultptr;
19504 resultptr = new wxDateTime((wxDateTime &)(result));
19505 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19506 }
19507 return resultobj;
19508 fail:
19509 return NULL;
19510 }
19511
19512
19513 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19514 PyObject *resultobj;
19515 int arg1 = (int) wxDateTime::Inv_Year ;
19516 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19517 wxDateTime result;
19518 PyObject * obj0 = 0 ;
19519 PyObject * obj1 = 0 ;
19520 char *kwnames[] = {
19521 (char *) "year",(char *) "country", NULL
19522 };
19523
19524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19525 if (obj0) {
19526 {
19527 arg1 = (int)(SWIG_As_int(obj0));
19528 if (SWIG_arg_fail(1)) SWIG_fail;
19529 }
19530 }
19531 if (obj1) {
19532 {
19533 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19534 if (SWIG_arg_fail(2)) SWIG_fail;
19535 }
19536 }
19537 {
19538 PyThreadState* __tstate = wxPyBeginAllowThreads();
19539 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19540
19541 wxPyEndAllowThreads(__tstate);
19542 if (PyErr_Occurred()) SWIG_fail;
19543 }
19544 {
19545 wxDateTime * resultptr;
19546 resultptr = new wxDateTime((wxDateTime &)(result));
19547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19548 }
19549 return resultobj;
19550 fail:
19551 return NULL;
19552 }
19553
19554
19555 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19556 PyObject *resultobj;
19557 wxDateTime result;
19558 char *kwnames[] = {
19559 NULL
19560 };
19561
19562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19563 {
19564 PyThreadState* __tstate = wxPyBeginAllowThreads();
19565 result = wxDateTime::Now();
19566
19567 wxPyEndAllowThreads(__tstate);
19568 if (PyErr_Occurred()) SWIG_fail;
19569 }
19570 {
19571 wxDateTime * resultptr;
19572 resultptr = new wxDateTime((wxDateTime &)(result));
19573 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19574 }
19575 return resultobj;
19576 fail:
19577 return NULL;
19578 }
19579
19580
19581 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19582 PyObject *resultobj;
19583 wxDateTime result;
19584 char *kwnames[] = {
19585 NULL
19586 };
19587
19588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19589 {
19590 PyThreadState* __tstate = wxPyBeginAllowThreads();
19591 result = wxDateTime::UNow();
19592
19593 wxPyEndAllowThreads(__tstate);
19594 if (PyErr_Occurred()) SWIG_fail;
19595 }
19596 {
19597 wxDateTime * resultptr;
19598 resultptr = new wxDateTime((wxDateTime &)(result));
19599 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19600 }
19601 return resultobj;
19602 fail:
19603 return NULL;
19604 }
19605
19606
19607 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19608 PyObject *resultobj;
19609 wxDateTime result;
19610 char *kwnames[] = {
19611 NULL
19612 };
19613
19614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19615 {
19616 PyThreadState* __tstate = wxPyBeginAllowThreads();
19617 result = wxDateTime::Today();
19618
19619 wxPyEndAllowThreads(__tstate);
19620 if (PyErr_Occurred()) SWIG_fail;
19621 }
19622 {
19623 wxDateTime * resultptr;
19624 resultptr = new wxDateTime((wxDateTime &)(result));
19625 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19626 }
19627 return resultobj;
19628 fail:
19629 return NULL;
19630 }
19631
19632
19633 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19634 PyObject *resultobj;
19635 wxDateTime *result;
19636 char *kwnames[] = {
19637 NULL
19638 };
19639
19640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19641 {
19642 PyThreadState* __tstate = wxPyBeginAllowThreads();
19643 result = (wxDateTime *)new wxDateTime();
19644
19645 wxPyEndAllowThreads(__tstate);
19646 if (PyErr_Occurred()) SWIG_fail;
19647 }
19648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19649 return resultobj;
19650 fail:
19651 return NULL;
19652 }
19653
19654
19655 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19656 PyObject *resultobj;
19657 time_t arg1 ;
19658 wxDateTime *result;
19659 PyObject * obj0 = 0 ;
19660 char *kwnames[] = {
19661 (char *) "timet", NULL
19662 };
19663
19664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19665 {
19666 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19667 if (SWIG_arg_fail(1)) SWIG_fail;
19668 }
19669 {
19670 PyThreadState* __tstate = wxPyBeginAllowThreads();
19671 result = (wxDateTime *)new wxDateTime(arg1);
19672
19673 wxPyEndAllowThreads(__tstate);
19674 if (PyErr_Occurred()) SWIG_fail;
19675 }
19676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19677 return resultobj;
19678 fail:
19679 return NULL;
19680 }
19681
19682
19683 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19684 PyObject *resultobj;
19685 double arg1 ;
19686 wxDateTime *result;
19687 PyObject * obj0 = 0 ;
19688 char *kwnames[] = {
19689 (char *) "jdn", NULL
19690 };
19691
19692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19693 {
19694 arg1 = (double)(SWIG_As_double(obj0));
19695 if (SWIG_arg_fail(1)) SWIG_fail;
19696 }
19697 {
19698 PyThreadState* __tstate = wxPyBeginAllowThreads();
19699 result = (wxDateTime *)new wxDateTime(arg1);
19700
19701 wxPyEndAllowThreads(__tstate);
19702 if (PyErr_Occurred()) SWIG_fail;
19703 }
19704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19705 return resultobj;
19706 fail:
19707 return NULL;
19708 }
19709
19710
19711 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19712 PyObject *resultobj;
19713 int arg1 ;
19714 int arg2 = (int) 0 ;
19715 int arg3 = (int) 0 ;
19716 int arg4 = (int) 0 ;
19717 wxDateTime *result;
19718 PyObject * obj0 = 0 ;
19719 PyObject * obj1 = 0 ;
19720 PyObject * obj2 = 0 ;
19721 PyObject * obj3 = 0 ;
19722 char *kwnames[] = {
19723 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19724 };
19725
19726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19727 {
19728 arg1 = (int)(SWIG_As_int(obj0));
19729 if (SWIG_arg_fail(1)) SWIG_fail;
19730 }
19731 if (obj1) {
19732 {
19733 arg2 = (int)(SWIG_As_int(obj1));
19734 if (SWIG_arg_fail(2)) SWIG_fail;
19735 }
19736 }
19737 if (obj2) {
19738 {
19739 arg3 = (int)(SWIG_As_int(obj2));
19740 if (SWIG_arg_fail(3)) SWIG_fail;
19741 }
19742 }
19743 if (obj3) {
19744 {
19745 arg4 = (int)(SWIG_As_int(obj3));
19746 if (SWIG_arg_fail(4)) SWIG_fail;
19747 }
19748 }
19749 {
19750 PyThreadState* __tstate = wxPyBeginAllowThreads();
19751 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19752
19753 wxPyEndAllowThreads(__tstate);
19754 if (PyErr_Occurred()) SWIG_fail;
19755 }
19756 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19757 return resultobj;
19758 fail:
19759 return NULL;
19760 }
19761
19762
19763 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19764 PyObject *resultobj;
19765 int arg1 ;
19766 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19767 int arg3 = (int) wxDateTime::Inv_Year ;
19768 int arg4 = (int) 0 ;
19769 int arg5 = (int) 0 ;
19770 int arg6 = (int) 0 ;
19771 int arg7 = (int) 0 ;
19772 wxDateTime *result;
19773 PyObject * obj0 = 0 ;
19774 PyObject * obj1 = 0 ;
19775 PyObject * obj2 = 0 ;
19776 PyObject * obj3 = 0 ;
19777 PyObject * obj4 = 0 ;
19778 PyObject * obj5 = 0 ;
19779 PyObject * obj6 = 0 ;
19780 char *kwnames[] = {
19781 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19782 };
19783
19784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19785 {
19786 arg1 = (int)(SWIG_As_int(obj0));
19787 if (SWIG_arg_fail(1)) SWIG_fail;
19788 }
19789 if (obj1) {
19790 {
19791 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19792 if (SWIG_arg_fail(2)) SWIG_fail;
19793 }
19794 }
19795 if (obj2) {
19796 {
19797 arg3 = (int)(SWIG_As_int(obj2));
19798 if (SWIG_arg_fail(3)) SWIG_fail;
19799 }
19800 }
19801 if (obj3) {
19802 {
19803 arg4 = (int)(SWIG_As_int(obj3));
19804 if (SWIG_arg_fail(4)) SWIG_fail;
19805 }
19806 }
19807 if (obj4) {
19808 {
19809 arg5 = (int)(SWIG_As_int(obj4));
19810 if (SWIG_arg_fail(5)) SWIG_fail;
19811 }
19812 }
19813 if (obj5) {
19814 {
19815 arg6 = (int)(SWIG_As_int(obj5));
19816 if (SWIG_arg_fail(6)) SWIG_fail;
19817 }
19818 }
19819 if (obj6) {
19820 {
19821 arg7 = (int)(SWIG_As_int(obj6));
19822 if (SWIG_arg_fail(7)) SWIG_fail;
19823 }
19824 }
19825 {
19826 PyThreadState* __tstate = wxPyBeginAllowThreads();
19827 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19828
19829 wxPyEndAllowThreads(__tstate);
19830 if (PyErr_Occurred()) SWIG_fail;
19831 }
19832 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19833 return resultobj;
19834 fail:
19835 return NULL;
19836 }
19837
19838
19839 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19840 PyObject *resultobj;
19841 wxDateTime *arg1 = (wxDateTime *) 0 ;
19842 PyObject * obj0 = 0 ;
19843 char *kwnames[] = {
19844 (char *) "self", NULL
19845 };
19846
19847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19849 if (SWIG_arg_fail(1)) SWIG_fail;
19850 {
19851 PyThreadState* __tstate = wxPyBeginAllowThreads();
19852 delete arg1;
19853
19854 wxPyEndAllowThreads(__tstate);
19855 if (PyErr_Occurred()) SWIG_fail;
19856 }
19857 Py_INCREF(Py_None); resultobj = Py_None;
19858 return resultobj;
19859 fail:
19860 return NULL;
19861 }
19862
19863
19864 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19865 PyObject *resultobj;
19866 wxDateTime *arg1 = (wxDateTime *) 0 ;
19867 wxDateTime *result;
19868 PyObject * obj0 = 0 ;
19869 char *kwnames[] = {
19870 (char *) "self", NULL
19871 };
19872
19873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19875 if (SWIG_arg_fail(1)) SWIG_fail;
19876 {
19877 PyThreadState* __tstate = wxPyBeginAllowThreads();
19878 {
19879 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19880 result = (wxDateTime *) &_result_ref;
19881 }
19882
19883 wxPyEndAllowThreads(__tstate);
19884 if (PyErr_Occurred()) SWIG_fail;
19885 }
19886 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19887 return resultobj;
19888 fail:
19889 return NULL;
19890 }
19891
19892
19893 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19894 PyObject *resultobj;
19895 wxDateTime *arg1 = (wxDateTime *) 0 ;
19896 time_t arg2 ;
19897 wxDateTime *result;
19898 PyObject * obj0 = 0 ;
19899 PyObject * obj1 = 0 ;
19900 char *kwnames[] = {
19901 (char *) "self",(char *) "timet", NULL
19902 };
19903
19904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19906 if (SWIG_arg_fail(1)) SWIG_fail;
19907 {
19908 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19909 if (SWIG_arg_fail(2)) SWIG_fail;
19910 }
19911 {
19912 PyThreadState* __tstate = wxPyBeginAllowThreads();
19913 {
19914 wxDateTime &_result_ref = (arg1)->Set(arg2);
19915 result = (wxDateTime *) &_result_ref;
19916 }
19917
19918 wxPyEndAllowThreads(__tstate);
19919 if (PyErr_Occurred()) SWIG_fail;
19920 }
19921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19922 return resultobj;
19923 fail:
19924 return NULL;
19925 }
19926
19927
19928 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19929 PyObject *resultobj;
19930 wxDateTime *arg1 = (wxDateTime *) 0 ;
19931 double arg2 ;
19932 wxDateTime *result;
19933 PyObject * obj0 = 0 ;
19934 PyObject * obj1 = 0 ;
19935 char *kwnames[] = {
19936 (char *) "self",(char *) "jdn", NULL
19937 };
19938
19939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19941 if (SWIG_arg_fail(1)) SWIG_fail;
19942 {
19943 arg2 = (double)(SWIG_As_double(obj1));
19944 if (SWIG_arg_fail(2)) SWIG_fail;
19945 }
19946 {
19947 PyThreadState* __tstate = wxPyBeginAllowThreads();
19948 {
19949 wxDateTime &_result_ref = (arg1)->Set(arg2);
19950 result = (wxDateTime *) &_result_ref;
19951 }
19952
19953 wxPyEndAllowThreads(__tstate);
19954 if (PyErr_Occurred()) SWIG_fail;
19955 }
19956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19957 return resultobj;
19958 fail:
19959 return NULL;
19960 }
19961
19962
19963 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19964 PyObject *resultobj;
19965 wxDateTime *arg1 = (wxDateTime *) 0 ;
19966 int arg2 ;
19967 int arg3 = (int) 0 ;
19968 int arg4 = (int) 0 ;
19969 int arg5 = (int) 0 ;
19970 wxDateTime *result;
19971 PyObject * obj0 = 0 ;
19972 PyObject * obj1 = 0 ;
19973 PyObject * obj2 = 0 ;
19974 PyObject * obj3 = 0 ;
19975 PyObject * obj4 = 0 ;
19976 char *kwnames[] = {
19977 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19978 };
19979
19980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19982 if (SWIG_arg_fail(1)) SWIG_fail;
19983 {
19984 arg2 = (int)(SWIG_As_int(obj1));
19985 if (SWIG_arg_fail(2)) SWIG_fail;
19986 }
19987 if (obj2) {
19988 {
19989 arg3 = (int)(SWIG_As_int(obj2));
19990 if (SWIG_arg_fail(3)) SWIG_fail;
19991 }
19992 }
19993 if (obj3) {
19994 {
19995 arg4 = (int)(SWIG_As_int(obj3));
19996 if (SWIG_arg_fail(4)) SWIG_fail;
19997 }
19998 }
19999 if (obj4) {
20000 {
20001 arg5 = (int)(SWIG_As_int(obj4));
20002 if (SWIG_arg_fail(5)) SWIG_fail;
20003 }
20004 }
20005 {
20006 PyThreadState* __tstate = wxPyBeginAllowThreads();
20007 {
20008 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20009 result = (wxDateTime *) &_result_ref;
20010 }
20011
20012 wxPyEndAllowThreads(__tstate);
20013 if (PyErr_Occurred()) SWIG_fail;
20014 }
20015 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20016 return resultobj;
20017 fail:
20018 return NULL;
20019 }
20020
20021
20022 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20023 PyObject *resultobj;
20024 wxDateTime *arg1 = (wxDateTime *) 0 ;
20025 int arg2 ;
20026 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20027 int arg4 = (int) wxDateTime::Inv_Year ;
20028 int arg5 = (int) 0 ;
20029 int arg6 = (int) 0 ;
20030 int arg7 = (int) 0 ;
20031 int arg8 = (int) 0 ;
20032 wxDateTime *result;
20033 PyObject * obj0 = 0 ;
20034 PyObject * obj1 = 0 ;
20035 PyObject * obj2 = 0 ;
20036 PyObject * obj3 = 0 ;
20037 PyObject * obj4 = 0 ;
20038 PyObject * obj5 = 0 ;
20039 PyObject * obj6 = 0 ;
20040 PyObject * obj7 = 0 ;
20041 char *kwnames[] = {
20042 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20043 };
20044
20045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20047 if (SWIG_arg_fail(1)) SWIG_fail;
20048 {
20049 arg2 = (int)(SWIG_As_int(obj1));
20050 if (SWIG_arg_fail(2)) SWIG_fail;
20051 }
20052 if (obj2) {
20053 {
20054 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20055 if (SWIG_arg_fail(3)) SWIG_fail;
20056 }
20057 }
20058 if (obj3) {
20059 {
20060 arg4 = (int)(SWIG_As_int(obj3));
20061 if (SWIG_arg_fail(4)) SWIG_fail;
20062 }
20063 }
20064 if (obj4) {
20065 {
20066 arg5 = (int)(SWIG_As_int(obj4));
20067 if (SWIG_arg_fail(5)) SWIG_fail;
20068 }
20069 }
20070 if (obj5) {
20071 {
20072 arg6 = (int)(SWIG_As_int(obj5));
20073 if (SWIG_arg_fail(6)) SWIG_fail;
20074 }
20075 }
20076 if (obj6) {
20077 {
20078 arg7 = (int)(SWIG_As_int(obj6));
20079 if (SWIG_arg_fail(7)) SWIG_fail;
20080 }
20081 }
20082 if (obj7) {
20083 {
20084 arg8 = (int)(SWIG_As_int(obj7));
20085 if (SWIG_arg_fail(8)) SWIG_fail;
20086 }
20087 }
20088 {
20089 PyThreadState* __tstate = wxPyBeginAllowThreads();
20090 {
20091 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20092 result = (wxDateTime *) &_result_ref;
20093 }
20094
20095 wxPyEndAllowThreads(__tstate);
20096 if (PyErr_Occurred()) SWIG_fail;
20097 }
20098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20099 return resultobj;
20100 fail:
20101 return NULL;
20102 }
20103
20104
20105 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20106 PyObject *resultobj;
20107 wxDateTime *arg1 = (wxDateTime *) 0 ;
20108 wxDateTime *result;
20109 PyObject * obj0 = 0 ;
20110 char *kwnames[] = {
20111 (char *) "self", NULL
20112 };
20113
20114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20116 if (SWIG_arg_fail(1)) SWIG_fail;
20117 {
20118 PyThreadState* __tstate = wxPyBeginAllowThreads();
20119 {
20120 wxDateTime &_result_ref = (arg1)->ResetTime();
20121 result = (wxDateTime *) &_result_ref;
20122 }
20123
20124 wxPyEndAllowThreads(__tstate);
20125 if (PyErr_Occurred()) SWIG_fail;
20126 }
20127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20128 return resultobj;
20129 fail:
20130 return NULL;
20131 }
20132
20133
20134 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20135 PyObject *resultobj;
20136 wxDateTime *arg1 = (wxDateTime *) 0 ;
20137 int arg2 ;
20138 wxDateTime *result;
20139 PyObject * obj0 = 0 ;
20140 PyObject * obj1 = 0 ;
20141 char *kwnames[] = {
20142 (char *) "self",(char *) "year", NULL
20143 };
20144
20145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20147 if (SWIG_arg_fail(1)) SWIG_fail;
20148 {
20149 arg2 = (int)(SWIG_As_int(obj1));
20150 if (SWIG_arg_fail(2)) SWIG_fail;
20151 }
20152 {
20153 PyThreadState* __tstate = wxPyBeginAllowThreads();
20154 {
20155 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20156 result = (wxDateTime *) &_result_ref;
20157 }
20158
20159 wxPyEndAllowThreads(__tstate);
20160 if (PyErr_Occurred()) SWIG_fail;
20161 }
20162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20163 return resultobj;
20164 fail:
20165 return NULL;
20166 }
20167
20168
20169 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20170 PyObject *resultobj;
20171 wxDateTime *arg1 = (wxDateTime *) 0 ;
20172 wxDateTime::Month arg2 ;
20173 wxDateTime *result;
20174 PyObject * obj0 = 0 ;
20175 PyObject * obj1 = 0 ;
20176 char *kwnames[] = {
20177 (char *) "self",(char *) "month", NULL
20178 };
20179
20180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20182 if (SWIG_arg_fail(1)) SWIG_fail;
20183 {
20184 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20185 if (SWIG_arg_fail(2)) SWIG_fail;
20186 }
20187 {
20188 PyThreadState* __tstate = wxPyBeginAllowThreads();
20189 {
20190 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
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_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20205 PyObject *resultobj;
20206 wxDateTime *arg1 = (wxDateTime *) 0 ;
20207 int arg2 ;
20208 wxDateTime *result;
20209 PyObject * obj0 = 0 ;
20210 PyObject * obj1 = 0 ;
20211 char *kwnames[] = {
20212 (char *) "self",(char *) "day", NULL
20213 };
20214
20215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20217 if (SWIG_arg_fail(1)) SWIG_fail;
20218 {
20219 arg2 = (int)(SWIG_As_int(obj1));
20220 if (SWIG_arg_fail(2)) SWIG_fail;
20221 }
20222 {
20223 PyThreadState* __tstate = wxPyBeginAllowThreads();
20224 {
20225 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20226 result = (wxDateTime *) &_result_ref;
20227 }
20228
20229 wxPyEndAllowThreads(__tstate);
20230 if (PyErr_Occurred()) SWIG_fail;
20231 }
20232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20233 return resultobj;
20234 fail:
20235 return NULL;
20236 }
20237
20238
20239 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20240 PyObject *resultobj;
20241 wxDateTime *arg1 = (wxDateTime *) 0 ;
20242 int arg2 ;
20243 wxDateTime *result;
20244 PyObject * obj0 = 0 ;
20245 PyObject * obj1 = 0 ;
20246 char *kwnames[] = {
20247 (char *) "self",(char *) "hour", NULL
20248 };
20249
20250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20252 if (SWIG_arg_fail(1)) SWIG_fail;
20253 {
20254 arg2 = (int)(SWIG_As_int(obj1));
20255 if (SWIG_arg_fail(2)) SWIG_fail;
20256 }
20257 {
20258 PyThreadState* __tstate = wxPyBeginAllowThreads();
20259 {
20260 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20261 result = (wxDateTime *) &_result_ref;
20262 }
20263
20264 wxPyEndAllowThreads(__tstate);
20265 if (PyErr_Occurred()) SWIG_fail;
20266 }
20267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20268 return resultobj;
20269 fail:
20270 return NULL;
20271 }
20272
20273
20274 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20275 PyObject *resultobj;
20276 wxDateTime *arg1 = (wxDateTime *) 0 ;
20277 int arg2 ;
20278 wxDateTime *result;
20279 PyObject * obj0 = 0 ;
20280 PyObject * obj1 = 0 ;
20281 char *kwnames[] = {
20282 (char *) "self",(char *) "minute", NULL
20283 };
20284
20285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20287 if (SWIG_arg_fail(1)) SWIG_fail;
20288 {
20289 arg2 = (int)(SWIG_As_int(obj1));
20290 if (SWIG_arg_fail(2)) SWIG_fail;
20291 }
20292 {
20293 PyThreadState* __tstate = wxPyBeginAllowThreads();
20294 {
20295 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20296 result = (wxDateTime *) &_result_ref;
20297 }
20298
20299 wxPyEndAllowThreads(__tstate);
20300 if (PyErr_Occurred()) SWIG_fail;
20301 }
20302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20303 return resultobj;
20304 fail:
20305 return NULL;
20306 }
20307
20308
20309 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20310 PyObject *resultobj;
20311 wxDateTime *arg1 = (wxDateTime *) 0 ;
20312 int arg2 ;
20313 wxDateTime *result;
20314 PyObject * obj0 = 0 ;
20315 PyObject * obj1 = 0 ;
20316 char *kwnames[] = {
20317 (char *) "self",(char *) "second", NULL
20318 };
20319
20320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20322 if (SWIG_arg_fail(1)) SWIG_fail;
20323 {
20324 arg2 = (int)(SWIG_As_int(obj1));
20325 if (SWIG_arg_fail(2)) SWIG_fail;
20326 }
20327 {
20328 PyThreadState* __tstate = wxPyBeginAllowThreads();
20329 {
20330 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20331 result = (wxDateTime *) &_result_ref;
20332 }
20333
20334 wxPyEndAllowThreads(__tstate);
20335 if (PyErr_Occurred()) SWIG_fail;
20336 }
20337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20338 return resultobj;
20339 fail:
20340 return NULL;
20341 }
20342
20343
20344 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20345 PyObject *resultobj;
20346 wxDateTime *arg1 = (wxDateTime *) 0 ;
20347 int arg2 ;
20348 wxDateTime *result;
20349 PyObject * obj0 = 0 ;
20350 PyObject * obj1 = 0 ;
20351 char *kwnames[] = {
20352 (char *) "self",(char *) "millisecond", NULL
20353 };
20354
20355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20357 if (SWIG_arg_fail(1)) SWIG_fail;
20358 {
20359 arg2 = (int)(SWIG_As_int(obj1));
20360 if (SWIG_arg_fail(2)) SWIG_fail;
20361 }
20362 {
20363 PyThreadState* __tstate = wxPyBeginAllowThreads();
20364 {
20365 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20366 result = (wxDateTime *) &_result_ref;
20367 }
20368
20369 wxPyEndAllowThreads(__tstate);
20370 if (PyErr_Occurred()) SWIG_fail;
20371 }
20372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20373 return resultobj;
20374 fail:
20375 return NULL;
20376 }
20377
20378
20379 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20380 PyObject *resultobj;
20381 wxDateTime *arg1 = (wxDateTime *) 0 ;
20382 wxDateTime::WeekDay arg2 ;
20383 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20384 wxDateTime *result;
20385 PyObject * obj0 = 0 ;
20386 PyObject * obj1 = 0 ;
20387 PyObject * obj2 = 0 ;
20388 char *kwnames[] = {
20389 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20390 };
20391
20392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20394 if (SWIG_arg_fail(1)) SWIG_fail;
20395 {
20396 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20397 if (SWIG_arg_fail(2)) SWIG_fail;
20398 }
20399 if (obj2) {
20400 {
20401 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20402 if (SWIG_arg_fail(3)) SWIG_fail;
20403 }
20404 }
20405 {
20406 PyThreadState* __tstate = wxPyBeginAllowThreads();
20407 {
20408 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20409 result = (wxDateTime *) &_result_ref;
20410 }
20411
20412 wxPyEndAllowThreads(__tstate);
20413 if (PyErr_Occurred()) SWIG_fail;
20414 }
20415 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20416 return resultobj;
20417 fail:
20418 return NULL;
20419 }
20420
20421
20422 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20423 PyObject *resultobj;
20424 wxDateTime *arg1 = (wxDateTime *) 0 ;
20425 wxDateTime::WeekDay arg2 ;
20426 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20427 wxDateTime result;
20428 PyObject * obj0 = 0 ;
20429 PyObject * obj1 = 0 ;
20430 PyObject * obj2 = 0 ;
20431 char *kwnames[] = {
20432 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20433 };
20434
20435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20437 if (SWIG_arg_fail(1)) SWIG_fail;
20438 {
20439 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20440 if (SWIG_arg_fail(2)) SWIG_fail;
20441 }
20442 if (obj2) {
20443 {
20444 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20445 if (SWIG_arg_fail(3)) SWIG_fail;
20446 }
20447 }
20448 {
20449 PyThreadState* __tstate = wxPyBeginAllowThreads();
20450 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20451
20452 wxPyEndAllowThreads(__tstate);
20453 if (PyErr_Occurred()) SWIG_fail;
20454 }
20455 {
20456 wxDateTime * resultptr;
20457 resultptr = new wxDateTime((wxDateTime &)(result));
20458 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20459 }
20460 return resultobj;
20461 fail:
20462 return NULL;
20463 }
20464
20465
20466 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20467 PyObject *resultobj;
20468 wxDateTime *arg1 = (wxDateTime *) 0 ;
20469 wxDateTime::WeekDay arg2 ;
20470 wxDateTime *result;
20471 PyObject * obj0 = 0 ;
20472 PyObject * obj1 = 0 ;
20473 char *kwnames[] = {
20474 (char *) "self",(char *) "weekday", NULL
20475 };
20476
20477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20479 if (SWIG_arg_fail(1)) SWIG_fail;
20480 {
20481 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20482 if (SWIG_arg_fail(2)) SWIG_fail;
20483 }
20484 {
20485 PyThreadState* __tstate = wxPyBeginAllowThreads();
20486 {
20487 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20488 result = (wxDateTime *) &_result_ref;
20489 }
20490
20491 wxPyEndAllowThreads(__tstate);
20492 if (PyErr_Occurred()) SWIG_fail;
20493 }
20494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20495 return resultobj;
20496 fail:
20497 return NULL;
20498 }
20499
20500
20501 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20502 PyObject *resultobj;
20503 wxDateTime *arg1 = (wxDateTime *) 0 ;
20504 wxDateTime::WeekDay arg2 ;
20505 wxDateTime result;
20506 PyObject * obj0 = 0 ;
20507 PyObject * obj1 = 0 ;
20508 char *kwnames[] = {
20509 (char *) "self",(char *) "weekday", NULL
20510 };
20511
20512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20514 if (SWIG_arg_fail(1)) SWIG_fail;
20515 {
20516 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20517 if (SWIG_arg_fail(2)) SWIG_fail;
20518 }
20519 {
20520 PyThreadState* __tstate = wxPyBeginAllowThreads();
20521 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20522
20523 wxPyEndAllowThreads(__tstate);
20524 if (PyErr_Occurred()) SWIG_fail;
20525 }
20526 {
20527 wxDateTime * resultptr;
20528 resultptr = new wxDateTime((wxDateTime &)(result));
20529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20530 }
20531 return resultobj;
20532 fail:
20533 return NULL;
20534 }
20535
20536
20537 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20538 PyObject *resultobj;
20539 wxDateTime *arg1 = (wxDateTime *) 0 ;
20540 wxDateTime::WeekDay arg2 ;
20541 wxDateTime *result;
20542 PyObject * obj0 = 0 ;
20543 PyObject * obj1 = 0 ;
20544 char *kwnames[] = {
20545 (char *) "self",(char *) "weekday", NULL
20546 };
20547
20548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20550 if (SWIG_arg_fail(1)) SWIG_fail;
20551 {
20552 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20553 if (SWIG_arg_fail(2)) SWIG_fail;
20554 }
20555 {
20556 PyThreadState* __tstate = wxPyBeginAllowThreads();
20557 {
20558 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20559 result = (wxDateTime *) &_result_ref;
20560 }
20561
20562 wxPyEndAllowThreads(__tstate);
20563 if (PyErr_Occurred()) SWIG_fail;
20564 }
20565 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20566 return resultobj;
20567 fail:
20568 return NULL;
20569 }
20570
20571
20572 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20573 PyObject *resultobj;
20574 wxDateTime *arg1 = (wxDateTime *) 0 ;
20575 wxDateTime::WeekDay arg2 ;
20576 wxDateTime result;
20577 PyObject * obj0 = 0 ;
20578 PyObject * obj1 = 0 ;
20579 char *kwnames[] = {
20580 (char *) "self",(char *) "weekday", NULL
20581 };
20582
20583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20585 if (SWIG_arg_fail(1)) SWIG_fail;
20586 {
20587 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20588 if (SWIG_arg_fail(2)) SWIG_fail;
20589 }
20590 {
20591 PyThreadState* __tstate = wxPyBeginAllowThreads();
20592 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20593
20594 wxPyEndAllowThreads(__tstate);
20595 if (PyErr_Occurred()) SWIG_fail;
20596 }
20597 {
20598 wxDateTime * resultptr;
20599 resultptr = new wxDateTime((wxDateTime &)(result));
20600 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20601 }
20602 return resultobj;
20603 fail:
20604 return NULL;
20605 }
20606
20607
20608 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20609 PyObject *resultobj;
20610 wxDateTime *arg1 = (wxDateTime *) 0 ;
20611 wxDateTime::WeekDay arg2 ;
20612 int arg3 = (int) 1 ;
20613 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20614 int arg5 = (int) wxDateTime::Inv_Year ;
20615 bool result;
20616 PyObject * obj0 = 0 ;
20617 PyObject * obj1 = 0 ;
20618 PyObject * obj2 = 0 ;
20619 PyObject * obj3 = 0 ;
20620 PyObject * obj4 = 0 ;
20621 char *kwnames[] = {
20622 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20623 };
20624
20625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20627 if (SWIG_arg_fail(1)) SWIG_fail;
20628 {
20629 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20630 if (SWIG_arg_fail(2)) SWIG_fail;
20631 }
20632 if (obj2) {
20633 {
20634 arg3 = (int)(SWIG_As_int(obj2));
20635 if (SWIG_arg_fail(3)) SWIG_fail;
20636 }
20637 }
20638 if (obj3) {
20639 {
20640 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20641 if (SWIG_arg_fail(4)) SWIG_fail;
20642 }
20643 }
20644 if (obj4) {
20645 {
20646 arg5 = (int)(SWIG_As_int(obj4));
20647 if (SWIG_arg_fail(5)) SWIG_fail;
20648 }
20649 }
20650 {
20651 PyThreadState* __tstate = wxPyBeginAllowThreads();
20652 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20653
20654 wxPyEndAllowThreads(__tstate);
20655 if (PyErr_Occurred()) SWIG_fail;
20656 }
20657 {
20658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20659 }
20660 return resultobj;
20661 fail:
20662 return NULL;
20663 }
20664
20665
20666 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20667 PyObject *resultobj;
20668 wxDateTime *arg1 = (wxDateTime *) 0 ;
20669 wxDateTime::WeekDay arg2 ;
20670 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20671 int arg4 = (int) wxDateTime::Inv_Year ;
20672 bool result;
20673 PyObject * obj0 = 0 ;
20674 PyObject * obj1 = 0 ;
20675 PyObject * obj2 = 0 ;
20676 PyObject * obj3 = 0 ;
20677 char *kwnames[] = {
20678 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20679 };
20680
20681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20683 if (SWIG_arg_fail(1)) SWIG_fail;
20684 {
20685 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20686 if (SWIG_arg_fail(2)) SWIG_fail;
20687 }
20688 if (obj2) {
20689 {
20690 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20691 if (SWIG_arg_fail(3)) SWIG_fail;
20692 }
20693 }
20694 if (obj3) {
20695 {
20696 arg4 = (int)(SWIG_As_int(obj3));
20697 if (SWIG_arg_fail(4)) SWIG_fail;
20698 }
20699 }
20700 {
20701 PyThreadState* __tstate = wxPyBeginAllowThreads();
20702 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20703
20704 wxPyEndAllowThreads(__tstate);
20705 if (PyErr_Occurred()) SWIG_fail;
20706 }
20707 {
20708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20709 }
20710 return resultobj;
20711 fail:
20712 return NULL;
20713 }
20714
20715
20716 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20717 PyObject *resultobj;
20718 wxDateTime *arg1 = (wxDateTime *) 0 ;
20719 wxDateTime::WeekDay arg2 ;
20720 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20721 int arg4 = (int) wxDateTime::Inv_Year ;
20722 wxDateTime result;
20723 PyObject * obj0 = 0 ;
20724 PyObject * obj1 = 0 ;
20725 PyObject * obj2 = 0 ;
20726 PyObject * obj3 = 0 ;
20727 char *kwnames[] = {
20728 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20729 };
20730
20731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20733 if (SWIG_arg_fail(1)) SWIG_fail;
20734 {
20735 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20736 if (SWIG_arg_fail(2)) SWIG_fail;
20737 }
20738 if (obj2) {
20739 {
20740 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20741 if (SWIG_arg_fail(3)) SWIG_fail;
20742 }
20743 }
20744 if (obj3) {
20745 {
20746 arg4 = (int)(SWIG_As_int(obj3));
20747 if (SWIG_arg_fail(4)) SWIG_fail;
20748 }
20749 }
20750 {
20751 PyThreadState* __tstate = wxPyBeginAllowThreads();
20752 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20753
20754 wxPyEndAllowThreads(__tstate);
20755 if (PyErr_Occurred()) SWIG_fail;
20756 }
20757 {
20758 wxDateTime * resultptr;
20759 resultptr = new wxDateTime((wxDateTime &)(result));
20760 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20761 }
20762 return resultobj;
20763 fail:
20764 return NULL;
20765 }
20766
20767
20768 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20769 PyObject *resultobj;
20770 wxDateTime *arg1 = (wxDateTime *) 0 ;
20771 int arg2 ;
20772 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20773 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20774 bool result;
20775 PyObject * obj0 = 0 ;
20776 PyObject * obj1 = 0 ;
20777 PyObject * obj2 = 0 ;
20778 PyObject * obj3 = 0 ;
20779 char *kwnames[] = {
20780 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20781 };
20782
20783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20785 if (SWIG_arg_fail(1)) SWIG_fail;
20786 {
20787 arg2 = (int)(SWIG_As_int(obj1));
20788 if (SWIG_arg_fail(2)) SWIG_fail;
20789 }
20790 if (obj2) {
20791 {
20792 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20793 if (SWIG_arg_fail(3)) SWIG_fail;
20794 }
20795 }
20796 if (obj3) {
20797 {
20798 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20799 if (SWIG_arg_fail(4)) SWIG_fail;
20800 }
20801 }
20802 {
20803 PyThreadState* __tstate = wxPyBeginAllowThreads();
20804 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20805
20806 wxPyEndAllowThreads(__tstate);
20807 if (PyErr_Occurred()) SWIG_fail;
20808 }
20809 {
20810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20811 }
20812 return resultobj;
20813 fail:
20814 return NULL;
20815 }
20816
20817
20818 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20819 PyObject *resultobj;
20820 wxDateTime *arg1 = (wxDateTime *) 0 ;
20821 int arg2 ;
20822 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20823 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20824 wxDateTime result;
20825 PyObject * obj0 = 0 ;
20826 PyObject * obj1 = 0 ;
20827 PyObject * obj2 = 0 ;
20828 PyObject * obj3 = 0 ;
20829 char *kwnames[] = {
20830 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20831 };
20832
20833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20835 if (SWIG_arg_fail(1)) SWIG_fail;
20836 {
20837 arg2 = (int)(SWIG_As_int(obj1));
20838 if (SWIG_arg_fail(2)) SWIG_fail;
20839 }
20840 if (obj2) {
20841 {
20842 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20843 if (SWIG_arg_fail(3)) SWIG_fail;
20844 }
20845 }
20846 if (obj3) {
20847 {
20848 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20849 if (SWIG_arg_fail(4)) SWIG_fail;
20850 }
20851 }
20852 {
20853 PyThreadState* __tstate = wxPyBeginAllowThreads();
20854 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20855
20856 wxPyEndAllowThreads(__tstate);
20857 if (PyErr_Occurred()) SWIG_fail;
20858 }
20859 {
20860 wxDateTime * resultptr;
20861 resultptr = new wxDateTime((wxDateTime &)(result));
20862 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20863 }
20864 return resultobj;
20865 fail:
20866 return NULL;
20867 }
20868
20869
20870 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20871 PyObject *resultobj;
20872 int arg1 ;
20873 int arg2 ;
20874 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20875 wxDateTime result;
20876 PyObject * obj0 = 0 ;
20877 PyObject * obj1 = 0 ;
20878 PyObject * obj2 = 0 ;
20879 char *kwnames[] = {
20880 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20881 };
20882
20883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20884 {
20885 arg1 = (int)(SWIG_As_int(obj0));
20886 if (SWIG_arg_fail(1)) SWIG_fail;
20887 }
20888 {
20889 arg2 = (int)(SWIG_As_int(obj1));
20890 if (SWIG_arg_fail(2)) SWIG_fail;
20891 }
20892 if (obj2) {
20893 {
20894 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20895 if (SWIG_arg_fail(3)) SWIG_fail;
20896 }
20897 }
20898 {
20899 PyThreadState* __tstate = wxPyBeginAllowThreads();
20900 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20901
20902 wxPyEndAllowThreads(__tstate);
20903 if (PyErr_Occurred()) SWIG_fail;
20904 }
20905 {
20906 wxDateTime * resultptr;
20907 resultptr = new wxDateTime((wxDateTime &)(result));
20908 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20909 }
20910 return resultobj;
20911 fail:
20912 return NULL;
20913 }
20914
20915
20916 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20917 PyObject *resultobj;
20918 wxDateTime *arg1 = (wxDateTime *) 0 ;
20919 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20920 int arg3 = (int) wxDateTime::Inv_Year ;
20921 wxDateTime *result;
20922 PyObject * obj0 = 0 ;
20923 PyObject * obj1 = 0 ;
20924 PyObject * obj2 = 0 ;
20925 char *kwnames[] = {
20926 (char *) "self",(char *) "month",(char *) "year", NULL
20927 };
20928
20929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20931 if (SWIG_arg_fail(1)) SWIG_fail;
20932 if (obj1) {
20933 {
20934 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20935 if (SWIG_arg_fail(2)) SWIG_fail;
20936 }
20937 }
20938 if (obj2) {
20939 {
20940 arg3 = (int)(SWIG_As_int(obj2));
20941 if (SWIG_arg_fail(3)) SWIG_fail;
20942 }
20943 }
20944 {
20945 PyThreadState* __tstate = wxPyBeginAllowThreads();
20946 {
20947 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20948 result = (wxDateTime *) &_result_ref;
20949 }
20950
20951 wxPyEndAllowThreads(__tstate);
20952 if (PyErr_Occurred()) SWIG_fail;
20953 }
20954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20955 return resultobj;
20956 fail:
20957 return NULL;
20958 }
20959
20960
20961 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20962 PyObject *resultobj;
20963 wxDateTime *arg1 = (wxDateTime *) 0 ;
20964 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20965 int arg3 = (int) wxDateTime::Inv_Year ;
20966 wxDateTime result;
20967 PyObject * obj0 = 0 ;
20968 PyObject * obj1 = 0 ;
20969 PyObject * obj2 = 0 ;
20970 char *kwnames[] = {
20971 (char *) "self",(char *) "month",(char *) "year", NULL
20972 };
20973
20974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20976 if (SWIG_arg_fail(1)) SWIG_fail;
20977 if (obj1) {
20978 {
20979 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20980 if (SWIG_arg_fail(2)) SWIG_fail;
20981 }
20982 }
20983 if (obj2) {
20984 {
20985 arg3 = (int)(SWIG_As_int(obj2));
20986 if (SWIG_arg_fail(3)) SWIG_fail;
20987 }
20988 }
20989 {
20990 PyThreadState* __tstate = wxPyBeginAllowThreads();
20991 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20992
20993 wxPyEndAllowThreads(__tstate);
20994 if (PyErr_Occurred()) SWIG_fail;
20995 }
20996 {
20997 wxDateTime * resultptr;
20998 resultptr = new wxDateTime((wxDateTime &)(result));
20999 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21000 }
21001 return resultobj;
21002 fail:
21003 return NULL;
21004 }
21005
21006
21007 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21008 PyObject *resultobj;
21009 wxDateTime *arg1 = (wxDateTime *) 0 ;
21010 int arg2 ;
21011 wxDateTime *result;
21012 PyObject * obj0 = 0 ;
21013 PyObject * obj1 = 0 ;
21014 char *kwnames[] = {
21015 (char *) "self",(char *) "yday", NULL
21016 };
21017
21018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21020 if (SWIG_arg_fail(1)) SWIG_fail;
21021 {
21022 arg2 = (int)(SWIG_As_int(obj1));
21023 if (SWIG_arg_fail(2)) SWIG_fail;
21024 }
21025 {
21026 PyThreadState* __tstate = wxPyBeginAllowThreads();
21027 {
21028 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21029 result = (wxDateTime *) &_result_ref;
21030 }
21031
21032 wxPyEndAllowThreads(__tstate);
21033 if (PyErr_Occurred()) SWIG_fail;
21034 }
21035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21036 return resultobj;
21037 fail:
21038 return NULL;
21039 }
21040
21041
21042 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21043 PyObject *resultobj;
21044 wxDateTime *arg1 = (wxDateTime *) 0 ;
21045 int arg2 ;
21046 wxDateTime result;
21047 PyObject * obj0 = 0 ;
21048 PyObject * obj1 = 0 ;
21049 char *kwnames[] = {
21050 (char *) "self",(char *) "yday", NULL
21051 };
21052
21053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21055 if (SWIG_arg_fail(1)) SWIG_fail;
21056 {
21057 arg2 = (int)(SWIG_As_int(obj1));
21058 if (SWIG_arg_fail(2)) SWIG_fail;
21059 }
21060 {
21061 PyThreadState* __tstate = wxPyBeginAllowThreads();
21062 result = (arg1)->GetYearDay(arg2);
21063
21064 wxPyEndAllowThreads(__tstate);
21065 if (PyErr_Occurred()) SWIG_fail;
21066 }
21067 {
21068 wxDateTime * resultptr;
21069 resultptr = new wxDateTime((wxDateTime &)(result));
21070 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21071 }
21072 return resultobj;
21073 fail:
21074 return NULL;
21075 }
21076
21077
21078 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21079 PyObject *resultobj;
21080 wxDateTime *arg1 = (wxDateTime *) 0 ;
21081 double result;
21082 PyObject * obj0 = 0 ;
21083 char *kwnames[] = {
21084 (char *) "self", NULL
21085 };
21086
21087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21089 if (SWIG_arg_fail(1)) SWIG_fail;
21090 {
21091 PyThreadState* __tstate = wxPyBeginAllowThreads();
21092 result = (double)(arg1)->GetJulianDayNumber();
21093
21094 wxPyEndAllowThreads(__tstate);
21095 if (PyErr_Occurred()) SWIG_fail;
21096 }
21097 {
21098 resultobj = SWIG_From_double((double)(result));
21099 }
21100 return resultobj;
21101 fail:
21102 return NULL;
21103 }
21104
21105
21106 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21107 PyObject *resultobj;
21108 wxDateTime *arg1 = (wxDateTime *) 0 ;
21109 double result;
21110 PyObject * obj0 = 0 ;
21111 char *kwnames[] = {
21112 (char *) "self", NULL
21113 };
21114
21115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21117 if (SWIG_arg_fail(1)) SWIG_fail;
21118 {
21119 PyThreadState* __tstate = wxPyBeginAllowThreads();
21120 result = (double)(arg1)->GetJDN();
21121
21122 wxPyEndAllowThreads(__tstate);
21123 if (PyErr_Occurred()) SWIG_fail;
21124 }
21125 {
21126 resultobj = SWIG_From_double((double)(result));
21127 }
21128 return resultobj;
21129 fail:
21130 return NULL;
21131 }
21132
21133
21134 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21135 PyObject *resultobj;
21136 wxDateTime *arg1 = (wxDateTime *) 0 ;
21137 double result;
21138 PyObject * obj0 = 0 ;
21139 char *kwnames[] = {
21140 (char *) "self", NULL
21141 };
21142
21143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21145 if (SWIG_arg_fail(1)) SWIG_fail;
21146 {
21147 PyThreadState* __tstate = wxPyBeginAllowThreads();
21148 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21149
21150 wxPyEndAllowThreads(__tstate);
21151 if (PyErr_Occurred()) SWIG_fail;
21152 }
21153 {
21154 resultobj = SWIG_From_double((double)(result));
21155 }
21156 return resultobj;
21157 fail:
21158 return NULL;
21159 }
21160
21161
21162 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21163 PyObject *resultobj;
21164 wxDateTime *arg1 = (wxDateTime *) 0 ;
21165 double result;
21166 PyObject * obj0 = 0 ;
21167 char *kwnames[] = {
21168 (char *) "self", NULL
21169 };
21170
21171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21173 if (SWIG_arg_fail(1)) SWIG_fail;
21174 {
21175 PyThreadState* __tstate = wxPyBeginAllowThreads();
21176 result = (double)(arg1)->GetMJD();
21177
21178 wxPyEndAllowThreads(__tstate);
21179 if (PyErr_Occurred()) SWIG_fail;
21180 }
21181 {
21182 resultobj = SWIG_From_double((double)(result));
21183 }
21184 return resultobj;
21185 fail:
21186 return NULL;
21187 }
21188
21189
21190 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21191 PyObject *resultobj;
21192 wxDateTime *arg1 = (wxDateTime *) 0 ;
21193 double result;
21194 PyObject * obj0 = 0 ;
21195 char *kwnames[] = {
21196 (char *) "self", NULL
21197 };
21198
21199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21201 if (SWIG_arg_fail(1)) SWIG_fail;
21202 {
21203 PyThreadState* __tstate = wxPyBeginAllowThreads();
21204 result = (double)(arg1)->GetRataDie();
21205
21206 wxPyEndAllowThreads(__tstate);
21207 if (PyErr_Occurred()) SWIG_fail;
21208 }
21209 {
21210 resultobj = SWIG_From_double((double)(result));
21211 }
21212 return resultobj;
21213 fail:
21214 return NULL;
21215 }
21216
21217
21218 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21219 PyObject *resultobj;
21220 wxDateTime *arg1 = (wxDateTime *) 0 ;
21221 wxDateTime::TimeZone *arg2 = 0 ;
21222 bool arg3 = (bool) false ;
21223 wxDateTime result;
21224 bool temp2 = false ;
21225 PyObject * obj0 = 0 ;
21226 PyObject * obj1 = 0 ;
21227 PyObject * obj2 = 0 ;
21228 char *kwnames[] = {
21229 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21230 };
21231
21232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21234 if (SWIG_arg_fail(1)) SWIG_fail;
21235 {
21236 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21237 temp2 = true;
21238 }
21239 if (obj2) {
21240 {
21241 arg3 = (bool)(SWIG_As_bool(obj2));
21242 if (SWIG_arg_fail(3)) SWIG_fail;
21243 }
21244 }
21245 {
21246 PyThreadState* __tstate = wxPyBeginAllowThreads();
21247 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21248
21249 wxPyEndAllowThreads(__tstate);
21250 if (PyErr_Occurred()) SWIG_fail;
21251 }
21252 {
21253 wxDateTime * resultptr;
21254 resultptr = new wxDateTime((wxDateTime &)(result));
21255 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21256 }
21257 {
21258 if (temp2) delete arg2;
21259 }
21260 return resultobj;
21261 fail:
21262 {
21263 if (temp2) delete arg2;
21264 }
21265 return NULL;
21266 }
21267
21268
21269 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21270 PyObject *resultobj;
21271 wxDateTime *arg1 = (wxDateTime *) 0 ;
21272 wxDateTime::TimeZone *arg2 = 0 ;
21273 bool arg3 = (bool) false ;
21274 wxDateTime *result;
21275 bool temp2 = false ;
21276 PyObject * obj0 = 0 ;
21277 PyObject * obj1 = 0 ;
21278 PyObject * obj2 = 0 ;
21279 char *kwnames[] = {
21280 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21281 };
21282
21283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21285 if (SWIG_arg_fail(1)) SWIG_fail;
21286 {
21287 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21288 temp2 = true;
21289 }
21290 if (obj2) {
21291 {
21292 arg3 = (bool)(SWIG_As_bool(obj2));
21293 if (SWIG_arg_fail(3)) SWIG_fail;
21294 }
21295 }
21296 {
21297 PyThreadState* __tstate = wxPyBeginAllowThreads();
21298 {
21299 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21300 result = (wxDateTime *) &_result_ref;
21301 }
21302
21303 wxPyEndAllowThreads(__tstate);
21304 if (PyErr_Occurred()) SWIG_fail;
21305 }
21306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21307 {
21308 if (temp2) delete arg2;
21309 }
21310 return resultobj;
21311 fail:
21312 {
21313 if (temp2) delete arg2;
21314 }
21315 return NULL;
21316 }
21317
21318
21319 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21320 PyObject *resultobj;
21321 wxDateTime *arg1 = (wxDateTime *) 0 ;
21322 bool arg2 = (bool) false ;
21323 wxDateTime result;
21324 PyObject * obj0 = 0 ;
21325 PyObject * obj1 = 0 ;
21326 char *kwnames[] = {
21327 (char *) "self",(char *) "noDST", NULL
21328 };
21329
21330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21332 if (SWIG_arg_fail(1)) SWIG_fail;
21333 if (obj1) {
21334 {
21335 arg2 = (bool)(SWIG_As_bool(obj1));
21336 if (SWIG_arg_fail(2)) SWIG_fail;
21337 }
21338 }
21339 {
21340 PyThreadState* __tstate = wxPyBeginAllowThreads();
21341 result = (arg1)->ToGMT(arg2);
21342
21343 wxPyEndAllowThreads(__tstate);
21344 if (PyErr_Occurred()) SWIG_fail;
21345 }
21346 {
21347 wxDateTime * resultptr;
21348 resultptr = new wxDateTime((wxDateTime &)(result));
21349 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21350 }
21351 return resultobj;
21352 fail:
21353 return NULL;
21354 }
21355
21356
21357 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21358 PyObject *resultobj;
21359 wxDateTime *arg1 = (wxDateTime *) 0 ;
21360 bool arg2 = (bool) false ;
21361 wxDateTime *result;
21362 PyObject * obj0 = 0 ;
21363 PyObject * obj1 = 0 ;
21364 char *kwnames[] = {
21365 (char *) "self",(char *) "noDST", NULL
21366 };
21367
21368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21370 if (SWIG_arg_fail(1)) SWIG_fail;
21371 if (obj1) {
21372 {
21373 arg2 = (bool)(SWIG_As_bool(obj1));
21374 if (SWIG_arg_fail(2)) SWIG_fail;
21375 }
21376 }
21377 {
21378 PyThreadState* __tstate = wxPyBeginAllowThreads();
21379 {
21380 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21381 result = (wxDateTime *) &_result_ref;
21382 }
21383
21384 wxPyEndAllowThreads(__tstate);
21385 if (PyErr_Occurred()) SWIG_fail;
21386 }
21387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21388 return resultobj;
21389 fail:
21390 return NULL;
21391 }
21392
21393
21394 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21395 PyObject *resultobj;
21396 wxDateTime *arg1 = (wxDateTime *) 0 ;
21397 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21398 int result;
21399 PyObject * obj0 = 0 ;
21400 PyObject * obj1 = 0 ;
21401 char *kwnames[] = {
21402 (char *) "self",(char *) "country", NULL
21403 };
21404
21405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21407 if (SWIG_arg_fail(1)) SWIG_fail;
21408 if (obj1) {
21409 {
21410 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21411 if (SWIG_arg_fail(2)) SWIG_fail;
21412 }
21413 }
21414 {
21415 PyThreadState* __tstate = wxPyBeginAllowThreads();
21416 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21417
21418 wxPyEndAllowThreads(__tstate);
21419 if (PyErr_Occurred()) SWIG_fail;
21420 }
21421 {
21422 resultobj = SWIG_From_int((int)(result));
21423 }
21424 return resultobj;
21425 fail:
21426 return NULL;
21427 }
21428
21429
21430 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21431 PyObject *resultobj;
21432 wxDateTime *arg1 = (wxDateTime *) 0 ;
21433 bool result;
21434 PyObject * obj0 = 0 ;
21435 char *kwnames[] = {
21436 (char *) "self", NULL
21437 };
21438
21439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21441 if (SWIG_arg_fail(1)) SWIG_fail;
21442 {
21443 PyThreadState* __tstate = wxPyBeginAllowThreads();
21444 result = (bool)((wxDateTime const *)arg1)->IsValid();
21445
21446 wxPyEndAllowThreads(__tstate);
21447 if (PyErr_Occurred()) SWIG_fail;
21448 }
21449 {
21450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21451 }
21452 return resultobj;
21453 fail:
21454 return NULL;
21455 }
21456
21457
21458 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21459 PyObject *resultobj;
21460 wxDateTime *arg1 = (wxDateTime *) 0 ;
21461 time_t result;
21462 PyObject * obj0 = 0 ;
21463 char *kwnames[] = {
21464 (char *) "self", NULL
21465 };
21466
21467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) 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 {
21471 PyThreadState* __tstate = wxPyBeginAllowThreads();
21472 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21473
21474 wxPyEndAllowThreads(__tstate);
21475 if (PyErr_Occurred()) SWIG_fail;
21476 }
21477 {
21478 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21479 }
21480 return resultobj;
21481 fail:
21482 return NULL;
21483 }
21484
21485
21486 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21487 PyObject *resultobj;
21488 wxDateTime *arg1 = (wxDateTime *) 0 ;
21489 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21490 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21491 int result;
21492 bool temp2 = false ;
21493 PyObject * obj0 = 0 ;
21494 PyObject * obj1 = 0 ;
21495 char *kwnames[] = {
21496 (char *) "self",(char *) "tz", NULL
21497 };
21498
21499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21501 if (SWIG_arg_fail(1)) SWIG_fail;
21502 if (obj1) {
21503 {
21504 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21505 temp2 = true;
21506 }
21507 }
21508 {
21509 PyThreadState* __tstate = wxPyBeginAllowThreads();
21510 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21511
21512 wxPyEndAllowThreads(__tstate);
21513 if (PyErr_Occurred()) SWIG_fail;
21514 }
21515 {
21516 resultobj = SWIG_From_int((int)(result));
21517 }
21518 {
21519 if (temp2) delete arg2;
21520 }
21521 return resultobj;
21522 fail:
21523 {
21524 if (temp2) delete arg2;
21525 }
21526 return NULL;
21527 }
21528
21529
21530 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21531 PyObject *resultobj;
21532 wxDateTime *arg1 = (wxDateTime *) 0 ;
21533 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21534 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21535 wxDateTime::Month result;
21536 bool temp2 = false ;
21537 PyObject * obj0 = 0 ;
21538 PyObject * obj1 = 0 ;
21539 char *kwnames[] = {
21540 (char *) "self",(char *) "tz", NULL
21541 };
21542
21543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21545 if (SWIG_arg_fail(1)) SWIG_fail;
21546 if (obj1) {
21547 {
21548 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21549 temp2 = true;
21550 }
21551 }
21552 {
21553 PyThreadState* __tstate = wxPyBeginAllowThreads();
21554 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21555
21556 wxPyEndAllowThreads(__tstate);
21557 if (PyErr_Occurred()) SWIG_fail;
21558 }
21559 resultobj = SWIG_From_int((result));
21560 {
21561 if (temp2) delete arg2;
21562 }
21563 return resultobj;
21564 fail:
21565 {
21566 if (temp2) delete arg2;
21567 }
21568 return NULL;
21569 }
21570
21571
21572 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21573 PyObject *resultobj;
21574 wxDateTime *arg1 = (wxDateTime *) 0 ;
21575 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21576 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21577 int result;
21578 bool temp2 = false ;
21579 PyObject * obj0 = 0 ;
21580 PyObject * obj1 = 0 ;
21581 char *kwnames[] = {
21582 (char *) "self",(char *) "tz", NULL
21583 };
21584
21585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21587 if (SWIG_arg_fail(1)) SWIG_fail;
21588 if (obj1) {
21589 {
21590 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21591 temp2 = true;
21592 }
21593 }
21594 {
21595 PyThreadState* __tstate = wxPyBeginAllowThreads();
21596 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21597
21598 wxPyEndAllowThreads(__tstate);
21599 if (PyErr_Occurred()) SWIG_fail;
21600 }
21601 {
21602 resultobj = SWIG_From_int((int)(result));
21603 }
21604 {
21605 if (temp2) delete arg2;
21606 }
21607 return resultobj;
21608 fail:
21609 {
21610 if (temp2) delete arg2;
21611 }
21612 return NULL;
21613 }
21614
21615
21616 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21617 PyObject *resultobj;
21618 wxDateTime *arg1 = (wxDateTime *) 0 ;
21619 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21620 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21621 wxDateTime::WeekDay result;
21622 bool temp2 = false ;
21623 PyObject * obj0 = 0 ;
21624 PyObject * obj1 = 0 ;
21625 char *kwnames[] = {
21626 (char *) "self",(char *) "tz", NULL
21627 };
21628
21629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21631 if (SWIG_arg_fail(1)) SWIG_fail;
21632 if (obj1) {
21633 {
21634 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21635 temp2 = true;
21636 }
21637 }
21638 {
21639 PyThreadState* __tstate = wxPyBeginAllowThreads();
21640 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21641
21642 wxPyEndAllowThreads(__tstate);
21643 if (PyErr_Occurred()) SWIG_fail;
21644 }
21645 resultobj = SWIG_From_int((result));
21646 {
21647 if (temp2) delete arg2;
21648 }
21649 return resultobj;
21650 fail:
21651 {
21652 if (temp2) delete arg2;
21653 }
21654 return NULL;
21655 }
21656
21657
21658 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21659 PyObject *resultobj;
21660 wxDateTime *arg1 = (wxDateTime *) 0 ;
21661 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21662 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21663 int result;
21664 bool temp2 = false ;
21665 PyObject * obj0 = 0 ;
21666 PyObject * obj1 = 0 ;
21667 char *kwnames[] = {
21668 (char *) "self",(char *) "tz", NULL
21669 };
21670
21671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21673 if (SWIG_arg_fail(1)) SWIG_fail;
21674 if (obj1) {
21675 {
21676 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21677 temp2 = true;
21678 }
21679 }
21680 {
21681 PyThreadState* __tstate = wxPyBeginAllowThreads();
21682 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21683
21684 wxPyEndAllowThreads(__tstate);
21685 if (PyErr_Occurred()) SWIG_fail;
21686 }
21687 {
21688 resultobj = SWIG_From_int((int)(result));
21689 }
21690 {
21691 if (temp2) delete arg2;
21692 }
21693 return resultobj;
21694 fail:
21695 {
21696 if (temp2) delete arg2;
21697 }
21698 return NULL;
21699 }
21700
21701
21702 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21703 PyObject *resultobj;
21704 wxDateTime *arg1 = (wxDateTime *) 0 ;
21705 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21706 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21707 int result;
21708 bool temp2 = false ;
21709 PyObject * obj0 = 0 ;
21710 PyObject * obj1 = 0 ;
21711 char *kwnames[] = {
21712 (char *) "self",(char *) "tz", NULL
21713 };
21714
21715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21717 if (SWIG_arg_fail(1)) SWIG_fail;
21718 if (obj1) {
21719 {
21720 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21721 temp2 = true;
21722 }
21723 }
21724 {
21725 PyThreadState* __tstate = wxPyBeginAllowThreads();
21726 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21727
21728 wxPyEndAllowThreads(__tstate);
21729 if (PyErr_Occurred()) SWIG_fail;
21730 }
21731 {
21732 resultobj = SWIG_From_int((int)(result));
21733 }
21734 {
21735 if (temp2) delete arg2;
21736 }
21737 return resultobj;
21738 fail:
21739 {
21740 if (temp2) delete arg2;
21741 }
21742 return NULL;
21743 }
21744
21745
21746 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21747 PyObject *resultobj;
21748 wxDateTime *arg1 = (wxDateTime *) 0 ;
21749 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21750 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21751 int result;
21752 bool temp2 = false ;
21753 PyObject * obj0 = 0 ;
21754 PyObject * obj1 = 0 ;
21755 char *kwnames[] = {
21756 (char *) "self",(char *) "tz", NULL
21757 };
21758
21759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21761 if (SWIG_arg_fail(1)) SWIG_fail;
21762 if (obj1) {
21763 {
21764 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21765 temp2 = true;
21766 }
21767 }
21768 {
21769 PyThreadState* __tstate = wxPyBeginAllowThreads();
21770 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21771
21772 wxPyEndAllowThreads(__tstate);
21773 if (PyErr_Occurred()) SWIG_fail;
21774 }
21775 {
21776 resultobj = SWIG_From_int((int)(result));
21777 }
21778 {
21779 if (temp2) delete arg2;
21780 }
21781 return resultobj;
21782 fail:
21783 {
21784 if (temp2) delete arg2;
21785 }
21786 return NULL;
21787 }
21788
21789
21790 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21791 PyObject *resultobj;
21792 wxDateTime *arg1 = (wxDateTime *) 0 ;
21793 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21794 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21795 int result;
21796 bool temp2 = false ;
21797 PyObject * obj0 = 0 ;
21798 PyObject * obj1 = 0 ;
21799 char *kwnames[] = {
21800 (char *) "self",(char *) "tz", NULL
21801 };
21802
21803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21805 if (SWIG_arg_fail(1)) SWIG_fail;
21806 if (obj1) {
21807 {
21808 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21809 temp2 = true;
21810 }
21811 }
21812 {
21813 PyThreadState* __tstate = wxPyBeginAllowThreads();
21814 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21815
21816 wxPyEndAllowThreads(__tstate);
21817 if (PyErr_Occurred()) SWIG_fail;
21818 }
21819 {
21820 resultobj = SWIG_From_int((int)(result));
21821 }
21822 {
21823 if (temp2) delete arg2;
21824 }
21825 return resultobj;
21826 fail:
21827 {
21828 if (temp2) delete arg2;
21829 }
21830 return NULL;
21831 }
21832
21833
21834 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21835 PyObject *resultobj;
21836 wxDateTime *arg1 = (wxDateTime *) 0 ;
21837 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21838 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21839 int result;
21840 bool temp2 = false ;
21841 PyObject * obj0 = 0 ;
21842 PyObject * obj1 = 0 ;
21843 char *kwnames[] = {
21844 (char *) "self",(char *) "tz", NULL
21845 };
21846
21847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21849 if (SWIG_arg_fail(1)) SWIG_fail;
21850 if (obj1) {
21851 {
21852 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21853 temp2 = true;
21854 }
21855 }
21856 {
21857 PyThreadState* __tstate = wxPyBeginAllowThreads();
21858 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21859
21860 wxPyEndAllowThreads(__tstate);
21861 if (PyErr_Occurred()) SWIG_fail;
21862 }
21863 {
21864 resultobj = SWIG_From_int((int)(result));
21865 }
21866 {
21867 if (temp2) delete arg2;
21868 }
21869 return resultobj;
21870 fail:
21871 {
21872 if (temp2) delete arg2;
21873 }
21874 return NULL;
21875 }
21876
21877
21878 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21879 PyObject *resultobj;
21880 wxDateTime *arg1 = (wxDateTime *) 0 ;
21881 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21882 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21883 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21884 int result;
21885 bool temp3 = false ;
21886 PyObject * obj0 = 0 ;
21887 PyObject * obj1 = 0 ;
21888 PyObject * obj2 = 0 ;
21889 char *kwnames[] = {
21890 (char *) "self",(char *) "flags",(char *) "tz", NULL
21891 };
21892
21893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21895 if (SWIG_arg_fail(1)) SWIG_fail;
21896 if (obj1) {
21897 {
21898 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21899 if (SWIG_arg_fail(2)) SWIG_fail;
21900 }
21901 }
21902 if (obj2) {
21903 {
21904 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21905 temp3 = true;
21906 }
21907 }
21908 {
21909 PyThreadState* __tstate = wxPyBeginAllowThreads();
21910 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21911
21912 wxPyEndAllowThreads(__tstate);
21913 if (PyErr_Occurred()) SWIG_fail;
21914 }
21915 {
21916 resultobj = SWIG_From_int((int)(result));
21917 }
21918 {
21919 if (temp3) delete arg3;
21920 }
21921 return resultobj;
21922 fail:
21923 {
21924 if (temp3) delete arg3;
21925 }
21926 return NULL;
21927 }
21928
21929
21930 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21931 PyObject *resultobj;
21932 wxDateTime *arg1 = (wxDateTime *) 0 ;
21933 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21934 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21935 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21936 int result;
21937 bool temp3 = false ;
21938 PyObject * obj0 = 0 ;
21939 PyObject * obj1 = 0 ;
21940 PyObject * obj2 = 0 ;
21941 char *kwnames[] = {
21942 (char *) "self",(char *) "flags",(char *) "tz", NULL
21943 };
21944
21945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21947 if (SWIG_arg_fail(1)) SWIG_fail;
21948 if (obj1) {
21949 {
21950 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21951 if (SWIG_arg_fail(2)) SWIG_fail;
21952 }
21953 }
21954 if (obj2) {
21955 {
21956 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21957 temp3 = true;
21958 }
21959 }
21960 {
21961 PyThreadState* __tstate = wxPyBeginAllowThreads();
21962 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21963
21964 wxPyEndAllowThreads(__tstate);
21965 if (PyErr_Occurred()) SWIG_fail;
21966 }
21967 {
21968 resultobj = SWIG_From_int((int)(result));
21969 }
21970 {
21971 if (temp3) delete arg3;
21972 }
21973 return resultobj;
21974 fail:
21975 {
21976 if (temp3) delete arg3;
21977 }
21978 return NULL;
21979 }
21980
21981
21982 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21983 PyObject *resultobj;
21984 wxDateTime *arg1 = (wxDateTime *) 0 ;
21985 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21986 bool result;
21987 PyObject * obj0 = 0 ;
21988 PyObject * obj1 = 0 ;
21989 char *kwnames[] = {
21990 (char *) "self",(char *) "country", NULL
21991 };
21992
21993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21995 if (SWIG_arg_fail(1)) SWIG_fail;
21996 if (obj1) {
21997 {
21998 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21999 if (SWIG_arg_fail(2)) SWIG_fail;
22000 }
22001 }
22002 {
22003 PyThreadState* __tstate = wxPyBeginAllowThreads();
22004 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22005
22006 wxPyEndAllowThreads(__tstate);
22007 if (PyErr_Occurred()) SWIG_fail;
22008 }
22009 {
22010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22011 }
22012 return resultobj;
22013 fail:
22014 return NULL;
22015 }
22016
22017
22018 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22019 PyObject *resultobj;
22020 wxDateTime *arg1 = (wxDateTime *) 0 ;
22021 wxDateTime *arg2 = 0 ;
22022 bool result;
22023 PyObject * obj0 = 0 ;
22024 PyObject * obj1 = 0 ;
22025 char *kwnames[] = {
22026 (char *) "self",(char *) "datetime", NULL
22027 };
22028
22029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22031 if (SWIG_arg_fail(1)) SWIG_fail;
22032 {
22033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22034 if (SWIG_arg_fail(2)) SWIG_fail;
22035 if (arg2 == NULL) {
22036 SWIG_null_ref("wxDateTime");
22037 }
22038 if (SWIG_arg_fail(2)) SWIG_fail;
22039 }
22040 {
22041 PyThreadState* __tstate = wxPyBeginAllowThreads();
22042 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22043
22044 wxPyEndAllowThreads(__tstate);
22045 if (PyErr_Occurred()) SWIG_fail;
22046 }
22047 {
22048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22049 }
22050 return resultobj;
22051 fail:
22052 return NULL;
22053 }
22054
22055
22056 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22057 PyObject *resultobj;
22058 wxDateTime *arg1 = (wxDateTime *) 0 ;
22059 wxDateTime *arg2 = 0 ;
22060 bool result;
22061 PyObject * obj0 = 0 ;
22062 PyObject * obj1 = 0 ;
22063 char *kwnames[] = {
22064 (char *) "self",(char *) "datetime", NULL
22065 };
22066
22067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22069 if (SWIG_arg_fail(1)) SWIG_fail;
22070 {
22071 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22072 if (SWIG_arg_fail(2)) SWIG_fail;
22073 if (arg2 == NULL) {
22074 SWIG_null_ref("wxDateTime");
22075 }
22076 if (SWIG_arg_fail(2)) SWIG_fail;
22077 }
22078 {
22079 PyThreadState* __tstate = wxPyBeginAllowThreads();
22080 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22081
22082 wxPyEndAllowThreads(__tstate);
22083 if (PyErr_Occurred()) SWIG_fail;
22084 }
22085 {
22086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22087 }
22088 return resultobj;
22089 fail:
22090 return NULL;
22091 }
22092
22093
22094 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22095 PyObject *resultobj;
22096 wxDateTime *arg1 = (wxDateTime *) 0 ;
22097 wxDateTime *arg2 = 0 ;
22098 bool result;
22099 PyObject * obj0 = 0 ;
22100 PyObject * obj1 = 0 ;
22101 char *kwnames[] = {
22102 (char *) "self",(char *) "datetime", NULL
22103 };
22104
22105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22107 if (SWIG_arg_fail(1)) SWIG_fail;
22108 {
22109 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22110 if (SWIG_arg_fail(2)) SWIG_fail;
22111 if (arg2 == NULL) {
22112 SWIG_null_ref("wxDateTime");
22113 }
22114 if (SWIG_arg_fail(2)) SWIG_fail;
22115 }
22116 {
22117 PyThreadState* __tstate = wxPyBeginAllowThreads();
22118 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22119
22120 wxPyEndAllowThreads(__tstate);
22121 if (PyErr_Occurred()) SWIG_fail;
22122 }
22123 {
22124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22125 }
22126 return resultobj;
22127 fail:
22128 return NULL;
22129 }
22130
22131
22132 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22133 PyObject *resultobj;
22134 wxDateTime *arg1 = (wxDateTime *) 0 ;
22135 wxDateTime *arg2 = 0 ;
22136 wxDateTime *arg3 = 0 ;
22137 bool result;
22138 PyObject * obj0 = 0 ;
22139 PyObject * obj1 = 0 ;
22140 PyObject * obj2 = 0 ;
22141 char *kwnames[] = {
22142 (char *) "self",(char *) "t1",(char *) "t2", NULL
22143 };
22144
22145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22147 if (SWIG_arg_fail(1)) SWIG_fail;
22148 {
22149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22150 if (SWIG_arg_fail(2)) SWIG_fail;
22151 if (arg2 == NULL) {
22152 SWIG_null_ref("wxDateTime");
22153 }
22154 if (SWIG_arg_fail(2)) SWIG_fail;
22155 }
22156 {
22157 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22158 if (SWIG_arg_fail(3)) SWIG_fail;
22159 if (arg3 == NULL) {
22160 SWIG_null_ref("wxDateTime");
22161 }
22162 if (SWIG_arg_fail(3)) SWIG_fail;
22163 }
22164 {
22165 PyThreadState* __tstate = wxPyBeginAllowThreads();
22166 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22167
22168 wxPyEndAllowThreads(__tstate);
22169 if (PyErr_Occurred()) SWIG_fail;
22170 }
22171 {
22172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22173 }
22174 return resultobj;
22175 fail:
22176 return NULL;
22177 }
22178
22179
22180 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22181 PyObject *resultobj;
22182 wxDateTime *arg1 = (wxDateTime *) 0 ;
22183 wxDateTime *arg2 = 0 ;
22184 wxDateTime *arg3 = 0 ;
22185 bool result;
22186 PyObject * obj0 = 0 ;
22187 PyObject * obj1 = 0 ;
22188 PyObject * obj2 = 0 ;
22189 char *kwnames[] = {
22190 (char *) "self",(char *) "t1",(char *) "t2", NULL
22191 };
22192
22193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22195 if (SWIG_arg_fail(1)) SWIG_fail;
22196 {
22197 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22198 if (SWIG_arg_fail(2)) SWIG_fail;
22199 if (arg2 == NULL) {
22200 SWIG_null_ref("wxDateTime");
22201 }
22202 if (SWIG_arg_fail(2)) SWIG_fail;
22203 }
22204 {
22205 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22206 if (SWIG_arg_fail(3)) SWIG_fail;
22207 if (arg3 == NULL) {
22208 SWIG_null_ref("wxDateTime");
22209 }
22210 if (SWIG_arg_fail(3)) SWIG_fail;
22211 }
22212 {
22213 PyThreadState* __tstate = wxPyBeginAllowThreads();
22214 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22215
22216 wxPyEndAllowThreads(__tstate);
22217 if (PyErr_Occurred()) SWIG_fail;
22218 }
22219 {
22220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22221 }
22222 return resultobj;
22223 fail:
22224 return NULL;
22225 }
22226
22227
22228 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22229 PyObject *resultobj;
22230 wxDateTime *arg1 = (wxDateTime *) 0 ;
22231 wxDateTime *arg2 = 0 ;
22232 bool result;
22233 PyObject * obj0 = 0 ;
22234 PyObject * obj1 = 0 ;
22235 char *kwnames[] = {
22236 (char *) "self",(char *) "dt", NULL
22237 };
22238
22239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22241 if (SWIG_arg_fail(1)) SWIG_fail;
22242 {
22243 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22244 if (SWIG_arg_fail(2)) SWIG_fail;
22245 if (arg2 == NULL) {
22246 SWIG_null_ref("wxDateTime");
22247 }
22248 if (SWIG_arg_fail(2)) SWIG_fail;
22249 }
22250 {
22251 PyThreadState* __tstate = wxPyBeginAllowThreads();
22252 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22253
22254 wxPyEndAllowThreads(__tstate);
22255 if (PyErr_Occurred()) SWIG_fail;
22256 }
22257 {
22258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22259 }
22260 return resultobj;
22261 fail:
22262 return NULL;
22263 }
22264
22265
22266 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22267 PyObject *resultobj;
22268 wxDateTime *arg1 = (wxDateTime *) 0 ;
22269 wxDateTime *arg2 = 0 ;
22270 bool result;
22271 PyObject * obj0 = 0 ;
22272 PyObject * obj1 = 0 ;
22273 char *kwnames[] = {
22274 (char *) "self",(char *) "dt", NULL
22275 };
22276
22277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22279 if (SWIG_arg_fail(1)) SWIG_fail;
22280 {
22281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22282 if (SWIG_arg_fail(2)) SWIG_fail;
22283 if (arg2 == NULL) {
22284 SWIG_null_ref("wxDateTime");
22285 }
22286 if (SWIG_arg_fail(2)) SWIG_fail;
22287 }
22288 {
22289 PyThreadState* __tstate = wxPyBeginAllowThreads();
22290 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22291
22292 wxPyEndAllowThreads(__tstate);
22293 if (PyErr_Occurred()) SWIG_fail;
22294 }
22295 {
22296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22297 }
22298 return resultobj;
22299 fail:
22300 return NULL;
22301 }
22302
22303
22304 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22305 PyObject *resultobj;
22306 wxDateTime *arg1 = (wxDateTime *) 0 ;
22307 wxDateTime *arg2 = 0 ;
22308 wxTimeSpan *arg3 = 0 ;
22309 bool result;
22310 PyObject * obj0 = 0 ;
22311 PyObject * obj1 = 0 ;
22312 PyObject * obj2 = 0 ;
22313 char *kwnames[] = {
22314 (char *) "self",(char *) "dt",(char *) "ts", NULL
22315 };
22316
22317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22319 if (SWIG_arg_fail(1)) SWIG_fail;
22320 {
22321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22322 if (SWIG_arg_fail(2)) SWIG_fail;
22323 if (arg2 == NULL) {
22324 SWIG_null_ref("wxDateTime");
22325 }
22326 if (SWIG_arg_fail(2)) SWIG_fail;
22327 }
22328 {
22329 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22330 if (SWIG_arg_fail(3)) SWIG_fail;
22331 if (arg3 == NULL) {
22332 SWIG_null_ref("wxTimeSpan");
22333 }
22334 if (SWIG_arg_fail(3)) SWIG_fail;
22335 }
22336 {
22337 PyThreadState* __tstate = wxPyBeginAllowThreads();
22338 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22339
22340 wxPyEndAllowThreads(__tstate);
22341 if (PyErr_Occurred()) SWIG_fail;
22342 }
22343 {
22344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22345 }
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22353 PyObject *resultobj;
22354 wxDateTime *arg1 = (wxDateTime *) 0 ;
22355 wxTimeSpan *arg2 = 0 ;
22356 wxDateTime *result;
22357 PyObject * obj0 = 0 ;
22358 PyObject * obj1 = 0 ;
22359 char *kwnames[] = {
22360 (char *) "self",(char *) "diff", NULL
22361 };
22362
22363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22365 if (SWIG_arg_fail(1)) SWIG_fail;
22366 {
22367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22368 if (SWIG_arg_fail(2)) SWIG_fail;
22369 if (arg2 == NULL) {
22370 SWIG_null_ref("wxTimeSpan");
22371 }
22372 if (SWIG_arg_fail(2)) SWIG_fail;
22373 }
22374 {
22375 PyThreadState* __tstate = wxPyBeginAllowThreads();
22376 {
22377 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22378 result = (wxDateTime *) &_result_ref;
22379 }
22380
22381 wxPyEndAllowThreads(__tstate);
22382 if (PyErr_Occurred()) SWIG_fail;
22383 }
22384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22385 return resultobj;
22386 fail:
22387 return NULL;
22388 }
22389
22390
22391 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22392 PyObject *resultobj;
22393 wxDateTime *arg1 = (wxDateTime *) 0 ;
22394 wxDateSpan *arg2 = 0 ;
22395 wxDateTime *result;
22396 PyObject * obj0 = 0 ;
22397 PyObject * obj1 = 0 ;
22398 char *kwnames[] = {
22399 (char *) "self",(char *) "diff", NULL
22400 };
22401
22402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22404 if (SWIG_arg_fail(1)) SWIG_fail;
22405 {
22406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22407 if (SWIG_arg_fail(2)) SWIG_fail;
22408 if (arg2 == NULL) {
22409 SWIG_null_ref("wxDateSpan");
22410 }
22411 if (SWIG_arg_fail(2)) SWIG_fail;
22412 }
22413 {
22414 PyThreadState* __tstate = wxPyBeginAllowThreads();
22415 {
22416 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22417 result = (wxDateTime *) &_result_ref;
22418 }
22419
22420 wxPyEndAllowThreads(__tstate);
22421 if (PyErr_Occurred()) SWIG_fail;
22422 }
22423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22424 return resultobj;
22425 fail:
22426 return NULL;
22427 }
22428
22429
22430 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22431 PyObject *resultobj;
22432 wxDateTime *arg1 = (wxDateTime *) 0 ;
22433 wxTimeSpan *arg2 = 0 ;
22434 wxDateTime *result;
22435 PyObject * obj0 = 0 ;
22436 PyObject * obj1 = 0 ;
22437 char *kwnames[] = {
22438 (char *) "self",(char *) "diff", NULL
22439 };
22440
22441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22443 if (SWIG_arg_fail(1)) SWIG_fail;
22444 {
22445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22446 if (SWIG_arg_fail(2)) SWIG_fail;
22447 if (arg2 == NULL) {
22448 SWIG_null_ref("wxTimeSpan");
22449 }
22450 if (SWIG_arg_fail(2)) SWIG_fail;
22451 }
22452 {
22453 PyThreadState* __tstate = wxPyBeginAllowThreads();
22454 {
22455 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22456 result = (wxDateTime *) &_result_ref;
22457 }
22458
22459 wxPyEndAllowThreads(__tstate);
22460 if (PyErr_Occurred()) SWIG_fail;
22461 }
22462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22463 return resultobj;
22464 fail:
22465 return NULL;
22466 }
22467
22468
22469 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22470 PyObject *resultobj;
22471 wxDateTime *arg1 = (wxDateTime *) 0 ;
22472 wxDateSpan *arg2 = 0 ;
22473 wxDateTime *result;
22474 PyObject * obj0 = 0 ;
22475 PyObject * obj1 = 0 ;
22476 char *kwnames[] = {
22477 (char *) "self",(char *) "diff", NULL
22478 };
22479
22480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22482 if (SWIG_arg_fail(1)) SWIG_fail;
22483 {
22484 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22485 if (SWIG_arg_fail(2)) SWIG_fail;
22486 if (arg2 == NULL) {
22487 SWIG_null_ref("wxDateSpan");
22488 }
22489 if (SWIG_arg_fail(2)) SWIG_fail;
22490 }
22491 {
22492 PyThreadState* __tstate = wxPyBeginAllowThreads();
22493 {
22494 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22495 result = (wxDateTime *) &_result_ref;
22496 }
22497
22498 wxPyEndAllowThreads(__tstate);
22499 if (PyErr_Occurred()) SWIG_fail;
22500 }
22501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22502 return resultobj;
22503 fail:
22504 return NULL;
22505 }
22506
22507
22508 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22509 PyObject *resultobj;
22510 wxDateTime *arg1 = (wxDateTime *) 0 ;
22511 wxDateTime *arg2 = 0 ;
22512 wxTimeSpan result;
22513 PyObject * obj0 = 0 ;
22514 PyObject * obj1 = 0 ;
22515 char *kwnames[] = {
22516 (char *) "self",(char *) "dt", NULL
22517 };
22518
22519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22521 if (SWIG_arg_fail(1)) SWIG_fail;
22522 {
22523 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22524 if (SWIG_arg_fail(2)) SWIG_fail;
22525 if (arg2 == NULL) {
22526 SWIG_null_ref("wxDateTime");
22527 }
22528 if (SWIG_arg_fail(2)) SWIG_fail;
22529 }
22530 {
22531 PyThreadState* __tstate = wxPyBeginAllowThreads();
22532 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22533
22534 wxPyEndAllowThreads(__tstate);
22535 if (PyErr_Occurred()) SWIG_fail;
22536 }
22537 {
22538 wxTimeSpan * resultptr;
22539 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22540 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22541 }
22542 return resultobj;
22543 fail:
22544 return NULL;
22545 }
22546
22547
22548 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22549 PyObject *resultobj;
22550 wxDateTime *arg1 = (wxDateTime *) 0 ;
22551 wxTimeSpan *arg2 = 0 ;
22552 wxDateTime *result;
22553 PyObject * obj0 = 0 ;
22554 PyObject * obj1 = 0 ;
22555
22556 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22558 if (SWIG_arg_fail(1)) SWIG_fail;
22559 {
22560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22561 if (SWIG_arg_fail(2)) SWIG_fail;
22562 if (arg2 == NULL) {
22563 SWIG_null_ref("wxTimeSpan");
22564 }
22565 if (SWIG_arg_fail(2)) SWIG_fail;
22566 }
22567 {
22568 PyThreadState* __tstate = wxPyBeginAllowThreads();
22569 {
22570 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22571 result = (wxDateTime *) &_result_ref;
22572 }
22573
22574 wxPyEndAllowThreads(__tstate);
22575 if (PyErr_Occurred()) SWIG_fail;
22576 }
22577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22578 return resultobj;
22579 fail:
22580 return NULL;
22581 }
22582
22583
22584 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22585 PyObject *resultobj;
22586 wxDateTime *arg1 = (wxDateTime *) 0 ;
22587 wxDateSpan *arg2 = 0 ;
22588 wxDateTime *result;
22589 PyObject * obj0 = 0 ;
22590 PyObject * obj1 = 0 ;
22591
22592 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22594 if (SWIG_arg_fail(1)) SWIG_fail;
22595 {
22596 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22597 if (SWIG_arg_fail(2)) SWIG_fail;
22598 if (arg2 == NULL) {
22599 SWIG_null_ref("wxDateSpan");
22600 }
22601 if (SWIG_arg_fail(2)) SWIG_fail;
22602 }
22603 {
22604 PyThreadState* __tstate = wxPyBeginAllowThreads();
22605 {
22606 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22607 result = (wxDateTime *) &_result_ref;
22608 }
22609
22610 wxPyEndAllowThreads(__tstate);
22611 if (PyErr_Occurred()) SWIG_fail;
22612 }
22613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22614 return resultobj;
22615 fail:
22616 return NULL;
22617 }
22618
22619
22620 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22621 int argc;
22622 PyObject *argv[3];
22623 int ii;
22624
22625 argc = PyObject_Length(args);
22626 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22627 argv[ii] = PyTuple_GetItem(args,ii);
22628 }
22629 if (argc == 2) {
22630 int _v;
22631 {
22632 void *ptr;
22633 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22634 _v = 0;
22635 PyErr_Clear();
22636 } else {
22637 _v = 1;
22638 }
22639 }
22640 if (_v) {
22641 {
22642 void *ptr = 0;
22643 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22644 _v = 0;
22645 PyErr_Clear();
22646 } else {
22647 _v = (ptr != 0);
22648 }
22649 }
22650 if (_v) {
22651 return _wrap_DateTime___iadd____SWIG_0(self,args);
22652 }
22653 }
22654 }
22655 if (argc == 2) {
22656 int _v;
22657 {
22658 void *ptr;
22659 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22660 _v = 0;
22661 PyErr_Clear();
22662 } else {
22663 _v = 1;
22664 }
22665 }
22666 if (_v) {
22667 {
22668 void *ptr = 0;
22669 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22670 _v = 0;
22671 PyErr_Clear();
22672 } else {
22673 _v = (ptr != 0);
22674 }
22675 }
22676 if (_v) {
22677 return _wrap_DateTime___iadd____SWIG_1(self,args);
22678 }
22679 }
22680 }
22681
22682 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22683 return NULL;
22684 }
22685
22686
22687 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22688 PyObject *resultobj;
22689 wxDateTime *arg1 = (wxDateTime *) 0 ;
22690 wxTimeSpan *arg2 = 0 ;
22691 wxDateTime *result;
22692 PyObject * obj0 = 0 ;
22693 PyObject * obj1 = 0 ;
22694
22695 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22697 if (SWIG_arg_fail(1)) SWIG_fail;
22698 {
22699 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22700 if (SWIG_arg_fail(2)) SWIG_fail;
22701 if (arg2 == NULL) {
22702 SWIG_null_ref("wxTimeSpan");
22703 }
22704 if (SWIG_arg_fail(2)) SWIG_fail;
22705 }
22706 {
22707 PyThreadState* __tstate = wxPyBeginAllowThreads();
22708 {
22709 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22710 result = (wxDateTime *) &_result_ref;
22711 }
22712
22713 wxPyEndAllowThreads(__tstate);
22714 if (PyErr_Occurred()) SWIG_fail;
22715 }
22716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22717 return resultobj;
22718 fail:
22719 return NULL;
22720 }
22721
22722
22723 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22724 PyObject *resultobj;
22725 wxDateTime *arg1 = (wxDateTime *) 0 ;
22726 wxDateSpan *arg2 = 0 ;
22727 wxDateTime *result;
22728 PyObject * obj0 = 0 ;
22729 PyObject * obj1 = 0 ;
22730
22731 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22733 if (SWIG_arg_fail(1)) SWIG_fail;
22734 {
22735 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22736 if (SWIG_arg_fail(2)) SWIG_fail;
22737 if (arg2 == NULL) {
22738 SWIG_null_ref("wxDateSpan");
22739 }
22740 if (SWIG_arg_fail(2)) SWIG_fail;
22741 }
22742 {
22743 PyThreadState* __tstate = wxPyBeginAllowThreads();
22744 {
22745 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22746 result = (wxDateTime *) &_result_ref;
22747 }
22748
22749 wxPyEndAllowThreads(__tstate);
22750 if (PyErr_Occurred()) SWIG_fail;
22751 }
22752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22753 return resultobj;
22754 fail:
22755 return NULL;
22756 }
22757
22758
22759 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22760 int argc;
22761 PyObject *argv[3];
22762 int ii;
22763
22764 argc = PyObject_Length(args);
22765 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22766 argv[ii] = PyTuple_GetItem(args,ii);
22767 }
22768 if (argc == 2) {
22769 int _v;
22770 {
22771 void *ptr;
22772 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22773 _v = 0;
22774 PyErr_Clear();
22775 } else {
22776 _v = 1;
22777 }
22778 }
22779 if (_v) {
22780 {
22781 void *ptr = 0;
22782 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22783 _v = 0;
22784 PyErr_Clear();
22785 } else {
22786 _v = (ptr != 0);
22787 }
22788 }
22789 if (_v) {
22790 return _wrap_DateTime___isub____SWIG_0(self,args);
22791 }
22792 }
22793 }
22794 if (argc == 2) {
22795 int _v;
22796 {
22797 void *ptr;
22798 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22799 _v = 0;
22800 PyErr_Clear();
22801 } else {
22802 _v = 1;
22803 }
22804 }
22805 if (_v) {
22806 {
22807 void *ptr = 0;
22808 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22809 _v = 0;
22810 PyErr_Clear();
22811 } else {
22812 _v = (ptr != 0);
22813 }
22814 }
22815 if (_v) {
22816 return _wrap_DateTime___isub____SWIG_1(self,args);
22817 }
22818 }
22819 }
22820
22821 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22822 return NULL;
22823 }
22824
22825
22826 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22827 PyObject *resultobj;
22828 wxDateTime *arg1 = (wxDateTime *) 0 ;
22829 wxTimeSpan *arg2 = 0 ;
22830 wxDateTime result;
22831 PyObject * obj0 = 0 ;
22832 PyObject * obj1 = 0 ;
22833
22834 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22836 if (SWIG_arg_fail(1)) SWIG_fail;
22837 {
22838 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22839 if (SWIG_arg_fail(2)) SWIG_fail;
22840 if (arg2 == NULL) {
22841 SWIG_null_ref("wxTimeSpan");
22842 }
22843 if (SWIG_arg_fail(2)) SWIG_fail;
22844 }
22845 {
22846 PyThreadState* __tstate = wxPyBeginAllowThreads();
22847 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22848
22849 wxPyEndAllowThreads(__tstate);
22850 if (PyErr_Occurred()) SWIG_fail;
22851 }
22852 {
22853 wxDateTime * resultptr;
22854 resultptr = new wxDateTime((wxDateTime &)(result));
22855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22856 }
22857 return resultobj;
22858 fail:
22859 return NULL;
22860 }
22861
22862
22863 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22864 PyObject *resultobj;
22865 wxDateTime *arg1 = (wxDateTime *) 0 ;
22866 wxDateSpan *arg2 = 0 ;
22867 wxDateTime result;
22868 PyObject * obj0 = 0 ;
22869 PyObject * obj1 = 0 ;
22870
22871 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22873 if (SWIG_arg_fail(1)) SWIG_fail;
22874 {
22875 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22876 if (SWIG_arg_fail(2)) SWIG_fail;
22877 if (arg2 == NULL) {
22878 SWIG_null_ref("wxDateSpan");
22879 }
22880 if (SWIG_arg_fail(2)) SWIG_fail;
22881 }
22882 {
22883 PyThreadState* __tstate = wxPyBeginAllowThreads();
22884 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22885
22886 wxPyEndAllowThreads(__tstate);
22887 if (PyErr_Occurred()) SWIG_fail;
22888 }
22889 {
22890 wxDateTime * resultptr;
22891 resultptr = new wxDateTime((wxDateTime &)(result));
22892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22893 }
22894 return resultobj;
22895 fail:
22896 return NULL;
22897 }
22898
22899
22900 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22901 int argc;
22902 PyObject *argv[3];
22903 int ii;
22904
22905 argc = PyObject_Length(args);
22906 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22907 argv[ii] = PyTuple_GetItem(args,ii);
22908 }
22909 if (argc == 2) {
22910 int _v;
22911 {
22912 void *ptr;
22913 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22914 _v = 0;
22915 PyErr_Clear();
22916 } else {
22917 _v = 1;
22918 }
22919 }
22920 if (_v) {
22921 {
22922 void *ptr = 0;
22923 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22924 _v = 0;
22925 PyErr_Clear();
22926 } else {
22927 _v = (ptr != 0);
22928 }
22929 }
22930 if (_v) {
22931 return _wrap_DateTime___add____SWIG_0(self,args);
22932 }
22933 }
22934 }
22935 if (argc == 2) {
22936 int _v;
22937 {
22938 void *ptr;
22939 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22940 _v = 0;
22941 PyErr_Clear();
22942 } else {
22943 _v = 1;
22944 }
22945 }
22946 if (_v) {
22947 {
22948 void *ptr = 0;
22949 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22950 _v = 0;
22951 PyErr_Clear();
22952 } else {
22953 _v = (ptr != 0);
22954 }
22955 }
22956 if (_v) {
22957 return _wrap_DateTime___add____SWIG_1(self,args);
22958 }
22959 }
22960 }
22961
22962 Py_INCREF(Py_NotImplemented);
22963 return Py_NotImplemented;
22964 }
22965
22966
22967 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22968 PyObject *resultobj;
22969 wxDateTime *arg1 = (wxDateTime *) 0 ;
22970 wxDateTime *arg2 = 0 ;
22971 wxTimeSpan result;
22972 PyObject * obj0 = 0 ;
22973 PyObject * obj1 = 0 ;
22974
22975 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22977 if (SWIG_arg_fail(1)) SWIG_fail;
22978 {
22979 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22980 if (SWIG_arg_fail(2)) SWIG_fail;
22981 if (arg2 == NULL) {
22982 SWIG_null_ref("wxDateTime");
22983 }
22984 if (SWIG_arg_fail(2)) SWIG_fail;
22985 }
22986 {
22987 PyThreadState* __tstate = wxPyBeginAllowThreads();
22988 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22989
22990 wxPyEndAllowThreads(__tstate);
22991 if (PyErr_Occurred()) SWIG_fail;
22992 }
22993 {
22994 wxTimeSpan * resultptr;
22995 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22996 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22997 }
22998 return resultobj;
22999 fail:
23000 return NULL;
23001 }
23002
23003
23004 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23005 PyObject *resultobj;
23006 wxDateTime *arg1 = (wxDateTime *) 0 ;
23007 wxTimeSpan *arg2 = 0 ;
23008 wxDateTime result;
23009 PyObject * obj0 = 0 ;
23010 PyObject * obj1 = 0 ;
23011
23012 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23014 if (SWIG_arg_fail(1)) SWIG_fail;
23015 {
23016 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23017 if (SWIG_arg_fail(2)) SWIG_fail;
23018 if (arg2 == NULL) {
23019 SWIG_null_ref("wxTimeSpan");
23020 }
23021 if (SWIG_arg_fail(2)) SWIG_fail;
23022 }
23023 {
23024 PyThreadState* __tstate = wxPyBeginAllowThreads();
23025 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23026
23027 wxPyEndAllowThreads(__tstate);
23028 if (PyErr_Occurred()) SWIG_fail;
23029 }
23030 {
23031 wxDateTime * resultptr;
23032 resultptr = new wxDateTime((wxDateTime &)(result));
23033 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23034 }
23035 return resultobj;
23036 fail:
23037 return NULL;
23038 }
23039
23040
23041 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23042 PyObject *resultobj;
23043 wxDateTime *arg1 = (wxDateTime *) 0 ;
23044 wxDateSpan *arg2 = 0 ;
23045 wxDateTime result;
23046 PyObject * obj0 = 0 ;
23047 PyObject * obj1 = 0 ;
23048
23049 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23051 if (SWIG_arg_fail(1)) SWIG_fail;
23052 {
23053 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23054 if (SWIG_arg_fail(2)) SWIG_fail;
23055 if (arg2 == NULL) {
23056 SWIG_null_ref("wxDateSpan");
23057 }
23058 if (SWIG_arg_fail(2)) SWIG_fail;
23059 }
23060 {
23061 PyThreadState* __tstate = wxPyBeginAllowThreads();
23062 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23063
23064 wxPyEndAllowThreads(__tstate);
23065 if (PyErr_Occurred()) SWIG_fail;
23066 }
23067 {
23068 wxDateTime * resultptr;
23069 resultptr = new wxDateTime((wxDateTime &)(result));
23070 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23071 }
23072 return resultobj;
23073 fail:
23074 return NULL;
23075 }
23076
23077
23078 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23079 int argc;
23080 PyObject *argv[3];
23081 int ii;
23082
23083 argc = PyObject_Length(args);
23084 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23085 argv[ii] = PyTuple_GetItem(args,ii);
23086 }
23087 if (argc == 2) {
23088 int _v;
23089 {
23090 void *ptr;
23091 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23092 _v = 0;
23093 PyErr_Clear();
23094 } else {
23095 _v = 1;
23096 }
23097 }
23098 if (_v) {
23099 {
23100 void *ptr = 0;
23101 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23102 _v = 0;
23103 PyErr_Clear();
23104 } else {
23105 _v = (ptr != 0);
23106 }
23107 }
23108 if (_v) {
23109 return _wrap_DateTime___sub____SWIG_0(self,args);
23110 }
23111 }
23112 }
23113 if (argc == 2) {
23114 int _v;
23115 {
23116 void *ptr;
23117 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23118 _v = 0;
23119 PyErr_Clear();
23120 } else {
23121 _v = 1;
23122 }
23123 }
23124 if (_v) {
23125 {
23126 void *ptr = 0;
23127 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23128 _v = 0;
23129 PyErr_Clear();
23130 } else {
23131 _v = (ptr != 0);
23132 }
23133 }
23134 if (_v) {
23135 return _wrap_DateTime___sub____SWIG_1(self,args);
23136 }
23137 }
23138 }
23139 if (argc == 2) {
23140 int _v;
23141 {
23142 void *ptr;
23143 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23144 _v = 0;
23145 PyErr_Clear();
23146 } else {
23147 _v = 1;
23148 }
23149 }
23150 if (_v) {
23151 {
23152 void *ptr = 0;
23153 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23154 _v = 0;
23155 PyErr_Clear();
23156 } else {
23157 _v = (ptr != 0);
23158 }
23159 }
23160 if (_v) {
23161 return _wrap_DateTime___sub____SWIG_2(self,args);
23162 }
23163 }
23164 }
23165
23166 Py_INCREF(Py_NotImplemented);
23167 return Py_NotImplemented;
23168 }
23169
23170
23171 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23172 PyObject *resultobj;
23173 wxDateTime *arg1 = (wxDateTime *) 0 ;
23174 wxDateTime *arg2 = (wxDateTime *) 0 ;
23175 bool result;
23176 PyObject * obj0 = 0 ;
23177 PyObject * obj1 = 0 ;
23178 char *kwnames[] = {
23179 (char *) "self",(char *) "other", NULL
23180 };
23181
23182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23184 if (SWIG_arg_fail(1)) SWIG_fail;
23185 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23186 if (SWIG_arg_fail(2)) SWIG_fail;
23187 {
23188 PyThreadState* __tstate = wxPyBeginAllowThreads();
23189 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23190
23191 wxPyEndAllowThreads(__tstate);
23192 if (PyErr_Occurred()) SWIG_fail;
23193 }
23194 {
23195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23196 }
23197 return resultobj;
23198 fail:
23199 return NULL;
23200 }
23201
23202
23203 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23204 PyObject *resultobj;
23205 wxDateTime *arg1 = (wxDateTime *) 0 ;
23206 wxDateTime *arg2 = (wxDateTime *) 0 ;
23207 bool result;
23208 PyObject * obj0 = 0 ;
23209 PyObject * obj1 = 0 ;
23210 char *kwnames[] = {
23211 (char *) "self",(char *) "other", NULL
23212 };
23213
23214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23216 if (SWIG_arg_fail(1)) SWIG_fail;
23217 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23218 if (SWIG_arg_fail(2)) SWIG_fail;
23219 {
23220 PyThreadState* __tstate = wxPyBeginAllowThreads();
23221 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23222
23223 wxPyEndAllowThreads(__tstate);
23224 if (PyErr_Occurred()) SWIG_fail;
23225 }
23226 {
23227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23228 }
23229 return resultobj;
23230 fail:
23231 return NULL;
23232 }
23233
23234
23235 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23236 PyObject *resultobj;
23237 wxDateTime *arg1 = (wxDateTime *) 0 ;
23238 wxDateTime *arg2 = (wxDateTime *) 0 ;
23239 bool result;
23240 PyObject * obj0 = 0 ;
23241 PyObject * obj1 = 0 ;
23242 char *kwnames[] = {
23243 (char *) "self",(char *) "other", NULL
23244 };
23245
23246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23248 if (SWIG_arg_fail(1)) SWIG_fail;
23249 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23250 if (SWIG_arg_fail(2)) SWIG_fail;
23251 {
23252 PyThreadState* __tstate = wxPyBeginAllowThreads();
23253 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23254
23255 wxPyEndAllowThreads(__tstate);
23256 if (PyErr_Occurred()) SWIG_fail;
23257 }
23258 {
23259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23260 }
23261 return resultobj;
23262 fail:
23263 return NULL;
23264 }
23265
23266
23267 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23268 PyObject *resultobj;
23269 wxDateTime *arg1 = (wxDateTime *) 0 ;
23270 wxDateTime *arg2 = (wxDateTime *) 0 ;
23271 bool result;
23272 PyObject * obj0 = 0 ;
23273 PyObject * obj1 = 0 ;
23274 char *kwnames[] = {
23275 (char *) "self",(char *) "other", NULL
23276 };
23277
23278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23280 if (SWIG_arg_fail(1)) SWIG_fail;
23281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23282 if (SWIG_arg_fail(2)) SWIG_fail;
23283 {
23284 PyThreadState* __tstate = wxPyBeginAllowThreads();
23285 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23286
23287 wxPyEndAllowThreads(__tstate);
23288 if (PyErr_Occurred()) SWIG_fail;
23289 }
23290 {
23291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23292 }
23293 return resultobj;
23294 fail:
23295 return NULL;
23296 }
23297
23298
23299 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23300 PyObject *resultobj;
23301 wxDateTime *arg1 = (wxDateTime *) 0 ;
23302 wxDateTime *arg2 = (wxDateTime *) 0 ;
23303 bool result;
23304 PyObject * obj0 = 0 ;
23305 PyObject * obj1 = 0 ;
23306 char *kwnames[] = {
23307 (char *) "self",(char *) "other", NULL
23308 };
23309
23310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23312 if (SWIG_arg_fail(1)) SWIG_fail;
23313 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23314 if (SWIG_arg_fail(2)) SWIG_fail;
23315 {
23316 PyThreadState* __tstate = wxPyBeginAllowThreads();
23317 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23318
23319 wxPyEndAllowThreads(__tstate);
23320 if (PyErr_Occurred()) SWIG_fail;
23321 }
23322 {
23323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23324 }
23325 return resultobj;
23326 fail:
23327 return NULL;
23328 }
23329
23330
23331 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23332 PyObject *resultobj;
23333 wxDateTime *arg1 = (wxDateTime *) 0 ;
23334 wxDateTime *arg2 = (wxDateTime *) 0 ;
23335 bool result;
23336 PyObject * obj0 = 0 ;
23337 PyObject * obj1 = 0 ;
23338 char *kwnames[] = {
23339 (char *) "self",(char *) "other", NULL
23340 };
23341
23342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23344 if (SWIG_arg_fail(1)) SWIG_fail;
23345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23346 if (SWIG_arg_fail(2)) SWIG_fail;
23347 {
23348 PyThreadState* __tstate = wxPyBeginAllowThreads();
23349 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23350
23351 wxPyEndAllowThreads(__tstate);
23352 if (PyErr_Occurred()) SWIG_fail;
23353 }
23354 {
23355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23356 }
23357 return resultobj;
23358 fail:
23359 return NULL;
23360 }
23361
23362
23363 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23364 PyObject *resultobj;
23365 wxDateTime *arg1 = (wxDateTime *) 0 ;
23366 wxString *arg2 = 0 ;
23367 int result;
23368 bool temp2 = false ;
23369 PyObject * obj0 = 0 ;
23370 PyObject * obj1 = 0 ;
23371 char *kwnames[] = {
23372 (char *) "self",(char *) "date", NULL
23373 };
23374
23375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23377 if (SWIG_arg_fail(1)) SWIG_fail;
23378 {
23379 arg2 = wxString_in_helper(obj1);
23380 if (arg2 == NULL) SWIG_fail;
23381 temp2 = true;
23382 }
23383 {
23384 PyThreadState* __tstate = wxPyBeginAllowThreads();
23385 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23386
23387 wxPyEndAllowThreads(__tstate);
23388 if (PyErr_Occurred()) SWIG_fail;
23389 }
23390 {
23391 resultobj = SWIG_From_int((int)(result));
23392 }
23393 {
23394 if (temp2)
23395 delete arg2;
23396 }
23397 return resultobj;
23398 fail:
23399 {
23400 if (temp2)
23401 delete arg2;
23402 }
23403 return NULL;
23404 }
23405
23406
23407 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23408 PyObject *resultobj;
23409 wxDateTime *arg1 = (wxDateTime *) 0 ;
23410 wxString *arg2 = 0 ;
23411 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23412 wxString *arg3 = (wxString *) &arg3_defvalue ;
23413 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23414 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23415 int result;
23416 bool temp2 = false ;
23417 bool temp3 = false ;
23418 PyObject * obj0 = 0 ;
23419 PyObject * obj1 = 0 ;
23420 PyObject * obj2 = 0 ;
23421 PyObject * obj3 = 0 ;
23422 char *kwnames[] = {
23423 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23424 };
23425
23426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23428 if (SWIG_arg_fail(1)) SWIG_fail;
23429 {
23430 arg2 = wxString_in_helper(obj1);
23431 if (arg2 == NULL) SWIG_fail;
23432 temp2 = true;
23433 }
23434 if (obj2) {
23435 {
23436 arg3 = wxString_in_helper(obj2);
23437 if (arg3 == NULL) SWIG_fail;
23438 temp3 = true;
23439 }
23440 }
23441 if (obj3) {
23442 {
23443 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23444 if (SWIG_arg_fail(4)) SWIG_fail;
23445 if (arg4 == NULL) {
23446 SWIG_null_ref("wxDateTime");
23447 }
23448 if (SWIG_arg_fail(4)) SWIG_fail;
23449 }
23450 }
23451 {
23452 PyThreadState* __tstate = wxPyBeginAllowThreads();
23453 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23454
23455 wxPyEndAllowThreads(__tstate);
23456 if (PyErr_Occurred()) SWIG_fail;
23457 }
23458 {
23459 resultobj = SWIG_From_int((int)(result));
23460 }
23461 {
23462 if (temp2)
23463 delete arg2;
23464 }
23465 {
23466 if (temp3)
23467 delete arg3;
23468 }
23469 return resultobj;
23470 fail:
23471 {
23472 if (temp2)
23473 delete arg2;
23474 }
23475 {
23476 if (temp3)
23477 delete arg3;
23478 }
23479 return NULL;
23480 }
23481
23482
23483 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23484 PyObject *resultobj;
23485 wxDateTime *arg1 = (wxDateTime *) 0 ;
23486 wxString *arg2 = 0 ;
23487 int result;
23488 bool temp2 = false ;
23489 PyObject * obj0 = 0 ;
23490 PyObject * obj1 = 0 ;
23491 char *kwnames[] = {
23492 (char *) "self",(char *) "datetime", NULL
23493 };
23494
23495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23497 if (SWIG_arg_fail(1)) SWIG_fail;
23498 {
23499 arg2 = wxString_in_helper(obj1);
23500 if (arg2 == NULL) SWIG_fail;
23501 temp2 = true;
23502 }
23503 {
23504 PyThreadState* __tstate = wxPyBeginAllowThreads();
23505 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23506
23507 wxPyEndAllowThreads(__tstate);
23508 if (PyErr_Occurred()) SWIG_fail;
23509 }
23510 {
23511 resultobj = SWIG_From_int((int)(result));
23512 }
23513 {
23514 if (temp2)
23515 delete arg2;
23516 }
23517 return resultobj;
23518 fail:
23519 {
23520 if (temp2)
23521 delete arg2;
23522 }
23523 return NULL;
23524 }
23525
23526
23527 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23528 PyObject *resultobj;
23529 wxDateTime *arg1 = (wxDateTime *) 0 ;
23530 wxString *arg2 = 0 ;
23531 int result;
23532 bool temp2 = false ;
23533 PyObject * obj0 = 0 ;
23534 PyObject * obj1 = 0 ;
23535 char *kwnames[] = {
23536 (char *) "self",(char *) "date", NULL
23537 };
23538
23539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23541 if (SWIG_arg_fail(1)) SWIG_fail;
23542 {
23543 arg2 = wxString_in_helper(obj1);
23544 if (arg2 == NULL) SWIG_fail;
23545 temp2 = true;
23546 }
23547 {
23548 PyThreadState* __tstate = wxPyBeginAllowThreads();
23549 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23550
23551 wxPyEndAllowThreads(__tstate);
23552 if (PyErr_Occurred()) SWIG_fail;
23553 }
23554 {
23555 resultobj = SWIG_From_int((int)(result));
23556 }
23557 {
23558 if (temp2)
23559 delete arg2;
23560 }
23561 return resultobj;
23562 fail:
23563 {
23564 if (temp2)
23565 delete arg2;
23566 }
23567 return NULL;
23568 }
23569
23570
23571 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23572 PyObject *resultobj;
23573 wxDateTime *arg1 = (wxDateTime *) 0 ;
23574 wxString *arg2 = 0 ;
23575 int result;
23576 bool temp2 = false ;
23577 PyObject * obj0 = 0 ;
23578 PyObject * obj1 = 0 ;
23579 char *kwnames[] = {
23580 (char *) "self",(char *) "time", NULL
23581 };
23582
23583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23585 if (SWIG_arg_fail(1)) SWIG_fail;
23586 {
23587 arg2 = wxString_in_helper(obj1);
23588 if (arg2 == NULL) SWIG_fail;
23589 temp2 = true;
23590 }
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23594
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 {
23599 resultobj = SWIG_From_int((int)(result));
23600 }
23601 {
23602 if (temp2)
23603 delete arg2;
23604 }
23605 return resultobj;
23606 fail:
23607 {
23608 if (temp2)
23609 delete arg2;
23610 }
23611 return NULL;
23612 }
23613
23614
23615 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23616 PyObject *resultobj;
23617 wxDateTime *arg1 = (wxDateTime *) 0 ;
23618 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23619 wxString *arg2 = (wxString *) &arg2_defvalue ;
23620 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23621 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23622 wxString result;
23623 bool temp2 = false ;
23624 bool temp3 = false ;
23625 PyObject * obj0 = 0 ;
23626 PyObject * obj1 = 0 ;
23627 PyObject * obj2 = 0 ;
23628 char *kwnames[] = {
23629 (char *) "self",(char *) "format",(char *) "tz", NULL
23630 };
23631
23632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23634 if (SWIG_arg_fail(1)) SWIG_fail;
23635 if (obj1) {
23636 {
23637 arg2 = wxString_in_helper(obj1);
23638 if (arg2 == NULL) SWIG_fail;
23639 temp2 = true;
23640 }
23641 }
23642 if (obj2) {
23643 {
23644 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23645 temp3 = true;
23646 }
23647 }
23648 {
23649 PyThreadState* __tstate = wxPyBeginAllowThreads();
23650 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23651
23652 wxPyEndAllowThreads(__tstate);
23653 if (PyErr_Occurred()) SWIG_fail;
23654 }
23655 {
23656 #if wxUSE_UNICODE
23657 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23658 #else
23659 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23660 #endif
23661 }
23662 {
23663 if (temp2)
23664 delete arg2;
23665 }
23666 {
23667 if (temp3) delete arg3;
23668 }
23669 return resultobj;
23670 fail:
23671 {
23672 if (temp2)
23673 delete arg2;
23674 }
23675 {
23676 if (temp3) delete arg3;
23677 }
23678 return NULL;
23679 }
23680
23681
23682 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23683 PyObject *resultobj;
23684 wxDateTime *arg1 = (wxDateTime *) 0 ;
23685 wxString result;
23686 PyObject * obj0 = 0 ;
23687 char *kwnames[] = {
23688 (char *) "self", NULL
23689 };
23690
23691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23693 if (SWIG_arg_fail(1)) SWIG_fail;
23694 {
23695 PyThreadState* __tstate = wxPyBeginAllowThreads();
23696 result = ((wxDateTime const *)arg1)->FormatDate();
23697
23698 wxPyEndAllowThreads(__tstate);
23699 if (PyErr_Occurred()) SWIG_fail;
23700 }
23701 {
23702 #if wxUSE_UNICODE
23703 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23704 #else
23705 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23706 #endif
23707 }
23708 return resultobj;
23709 fail:
23710 return NULL;
23711 }
23712
23713
23714 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23715 PyObject *resultobj;
23716 wxDateTime *arg1 = (wxDateTime *) 0 ;
23717 wxString result;
23718 PyObject * obj0 = 0 ;
23719 char *kwnames[] = {
23720 (char *) "self", NULL
23721 };
23722
23723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23725 if (SWIG_arg_fail(1)) SWIG_fail;
23726 {
23727 PyThreadState* __tstate = wxPyBeginAllowThreads();
23728 result = ((wxDateTime const *)arg1)->FormatTime();
23729
23730 wxPyEndAllowThreads(__tstate);
23731 if (PyErr_Occurred()) SWIG_fail;
23732 }
23733 {
23734 #if wxUSE_UNICODE
23735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23736 #else
23737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23738 #endif
23739 }
23740 return resultobj;
23741 fail:
23742 return NULL;
23743 }
23744
23745
23746 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23747 PyObject *resultobj;
23748 wxDateTime *arg1 = (wxDateTime *) 0 ;
23749 wxString result;
23750 PyObject * obj0 = 0 ;
23751 char *kwnames[] = {
23752 (char *) "self", NULL
23753 };
23754
23755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23757 if (SWIG_arg_fail(1)) SWIG_fail;
23758 {
23759 PyThreadState* __tstate = wxPyBeginAllowThreads();
23760 result = ((wxDateTime const *)arg1)->FormatISODate();
23761
23762 wxPyEndAllowThreads(__tstate);
23763 if (PyErr_Occurred()) SWIG_fail;
23764 }
23765 {
23766 #if wxUSE_UNICODE
23767 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23768 #else
23769 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23770 #endif
23771 }
23772 return resultobj;
23773 fail:
23774 return NULL;
23775 }
23776
23777
23778 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23779 PyObject *resultobj;
23780 wxDateTime *arg1 = (wxDateTime *) 0 ;
23781 wxString result;
23782 PyObject * obj0 = 0 ;
23783 char *kwnames[] = {
23784 (char *) "self", NULL
23785 };
23786
23787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23789 if (SWIG_arg_fail(1)) SWIG_fail;
23790 {
23791 PyThreadState* __tstate = wxPyBeginAllowThreads();
23792 result = ((wxDateTime const *)arg1)->FormatISOTime();
23793
23794 wxPyEndAllowThreads(__tstate);
23795 if (PyErr_Occurred()) SWIG_fail;
23796 }
23797 {
23798 #if wxUSE_UNICODE
23799 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23800 #else
23801 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23802 #endif
23803 }
23804 return resultobj;
23805 fail:
23806 return NULL;
23807 }
23808
23809
23810 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23811 PyObject *obj;
23812 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23813 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23814 Py_INCREF(obj);
23815 return Py_BuildValue((char *)"");
23816 }
23817 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23818 PyObject *resultobj;
23819 long arg1 ;
23820 wxTimeSpan result;
23821 PyObject * obj0 = 0 ;
23822 char *kwnames[] = {
23823 (char *) "sec", NULL
23824 };
23825
23826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23827 {
23828 arg1 = (long)(SWIG_As_long(obj0));
23829 if (SWIG_arg_fail(1)) SWIG_fail;
23830 }
23831 {
23832 PyThreadState* __tstate = wxPyBeginAllowThreads();
23833 result = wxTimeSpan::Seconds(arg1);
23834
23835 wxPyEndAllowThreads(__tstate);
23836 if (PyErr_Occurred()) SWIG_fail;
23837 }
23838 {
23839 wxTimeSpan * resultptr;
23840 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23841 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23842 }
23843 return resultobj;
23844 fail:
23845 return NULL;
23846 }
23847
23848
23849 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23850 PyObject *resultobj;
23851 wxTimeSpan result;
23852 char *kwnames[] = {
23853 NULL
23854 };
23855
23856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23857 {
23858 PyThreadState* __tstate = wxPyBeginAllowThreads();
23859 result = wxTimeSpan::Second();
23860
23861 wxPyEndAllowThreads(__tstate);
23862 if (PyErr_Occurred()) SWIG_fail;
23863 }
23864 {
23865 wxTimeSpan * resultptr;
23866 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23867 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23868 }
23869 return resultobj;
23870 fail:
23871 return NULL;
23872 }
23873
23874
23875 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23876 PyObject *resultobj;
23877 long arg1 ;
23878 wxTimeSpan result;
23879 PyObject * obj0 = 0 ;
23880 char *kwnames[] = {
23881 (char *) "min", NULL
23882 };
23883
23884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23885 {
23886 arg1 = (long)(SWIG_As_long(obj0));
23887 if (SWIG_arg_fail(1)) SWIG_fail;
23888 }
23889 {
23890 PyThreadState* __tstate = wxPyBeginAllowThreads();
23891 result = wxTimeSpan::Minutes(arg1);
23892
23893 wxPyEndAllowThreads(__tstate);
23894 if (PyErr_Occurred()) SWIG_fail;
23895 }
23896 {
23897 wxTimeSpan * resultptr;
23898 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23899 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23900 }
23901 return resultobj;
23902 fail:
23903 return NULL;
23904 }
23905
23906
23907 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23908 PyObject *resultobj;
23909 wxTimeSpan result;
23910 char *kwnames[] = {
23911 NULL
23912 };
23913
23914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23915 {
23916 PyThreadState* __tstate = wxPyBeginAllowThreads();
23917 result = wxTimeSpan::Minute();
23918
23919 wxPyEndAllowThreads(__tstate);
23920 if (PyErr_Occurred()) SWIG_fail;
23921 }
23922 {
23923 wxTimeSpan * resultptr;
23924 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23925 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23926 }
23927 return resultobj;
23928 fail:
23929 return NULL;
23930 }
23931
23932
23933 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23934 PyObject *resultobj;
23935 long arg1 ;
23936 wxTimeSpan result;
23937 PyObject * obj0 = 0 ;
23938 char *kwnames[] = {
23939 (char *) "hours", NULL
23940 };
23941
23942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23943 {
23944 arg1 = (long)(SWIG_As_long(obj0));
23945 if (SWIG_arg_fail(1)) SWIG_fail;
23946 }
23947 {
23948 PyThreadState* __tstate = wxPyBeginAllowThreads();
23949 result = wxTimeSpan::Hours(arg1);
23950
23951 wxPyEndAllowThreads(__tstate);
23952 if (PyErr_Occurred()) SWIG_fail;
23953 }
23954 {
23955 wxTimeSpan * resultptr;
23956 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23958 }
23959 return resultobj;
23960 fail:
23961 return NULL;
23962 }
23963
23964
23965 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23966 PyObject *resultobj;
23967 wxTimeSpan result;
23968 char *kwnames[] = {
23969 NULL
23970 };
23971
23972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23973 {
23974 PyThreadState* __tstate = wxPyBeginAllowThreads();
23975 result = wxTimeSpan::Hour();
23976
23977 wxPyEndAllowThreads(__tstate);
23978 if (PyErr_Occurred()) SWIG_fail;
23979 }
23980 {
23981 wxTimeSpan * resultptr;
23982 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23983 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23984 }
23985 return resultobj;
23986 fail:
23987 return NULL;
23988 }
23989
23990
23991 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23992 PyObject *resultobj;
23993 long arg1 ;
23994 wxTimeSpan result;
23995 PyObject * obj0 = 0 ;
23996 char *kwnames[] = {
23997 (char *) "days", NULL
23998 };
23999
24000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24001 {
24002 arg1 = (long)(SWIG_As_long(obj0));
24003 if (SWIG_arg_fail(1)) SWIG_fail;
24004 }
24005 {
24006 PyThreadState* __tstate = wxPyBeginAllowThreads();
24007 result = wxTimeSpan::Days(arg1);
24008
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 {
24013 wxTimeSpan * resultptr;
24014 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24015 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24016 }
24017 return resultobj;
24018 fail:
24019 return NULL;
24020 }
24021
24022
24023 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24024 PyObject *resultobj;
24025 wxTimeSpan result;
24026 char *kwnames[] = {
24027 NULL
24028 };
24029
24030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24031 {
24032 PyThreadState* __tstate = wxPyBeginAllowThreads();
24033 result = wxTimeSpan::Day();
24034
24035 wxPyEndAllowThreads(__tstate);
24036 if (PyErr_Occurred()) SWIG_fail;
24037 }
24038 {
24039 wxTimeSpan * resultptr;
24040 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24042 }
24043 return resultobj;
24044 fail:
24045 return NULL;
24046 }
24047
24048
24049 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24050 PyObject *resultobj;
24051 long arg1 ;
24052 wxTimeSpan result;
24053 PyObject * obj0 = 0 ;
24054 char *kwnames[] = {
24055 (char *) "days", NULL
24056 };
24057
24058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24059 {
24060 arg1 = (long)(SWIG_As_long(obj0));
24061 if (SWIG_arg_fail(1)) SWIG_fail;
24062 }
24063 {
24064 PyThreadState* __tstate = wxPyBeginAllowThreads();
24065 result = wxTimeSpan::Weeks(arg1);
24066
24067 wxPyEndAllowThreads(__tstate);
24068 if (PyErr_Occurred()) SWIG_fail;
24069 }
24070 {
24071 wxTimeSpan * resultptr;
24072 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24073 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24074 }
24075 return resultobj;
24076 fail:
24077 return NULL;
24078 }
24079
24080
24081 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24082 PyObject *resultobj;
24083 wxTimeSpan result;
24084 char *kwnames[] = {
24085 NULL
24086 };
24087
24088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24089 {
24090 PyThreadState* __tstate = wxPyBeginAllowThreads();
24091 result = wxTimeSpan::Week();
24092
24093 wxPyEndAllowThreads(__tstate);
24094 if (PyErr_Occurred()) SWIG_fail;
24095 }
24096 {
24097 wxTimeSpan * resultptr;
24098 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24099 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24100 }
24101 return resultobj;
24102 fail:
24103 return NULL;
24104 }
24105
24106
24107 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24108 PyObject *resultobj;
24109 long arg1 = (long) 0 ;
24110 long arg2 = (long) 0 ;
24111 long arg3 = (long) 0 ;
24112 long arg4 = (long) 0 ;
24113 wxTimeSpan *result;
24114 PyObject * obj0 = 0 ;
24115 PyObject * obj1 = 0 ;
24116 PyObject * obj2 = 0 ;
24117 PyObject * obj3 = 0 ;
24118 char *kwnames[] = {
24119 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24120 };
24121
24122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24123 if (obj0) {
24124 {
24125 arg1 = (long)(SWIG_As_long(obj0));
24126 if (SWIG_arg_fail(1)) SWIG_fail;
24127 }
24128 }
24129 if (obj1) {
24130 {
24131 arg2 = (long)(SWIG_As_long(obj1));
24132 if (SWIG_arg_fail(2)) SWIG_fail;
24133 }
24134 }
24135 if (obj2) {
24136 {
24137 arg3 = (long)(SWIG_As_long(obj2));
24138 if (SWIG_arg_fail(3)) SWIG_fail;
24139 }
24140 }
24141 if (obj3) {
24142 {
24143 arg4 = (long)(SWIG_As_long(obj3));
24144 if (SWIG_arg_fail(4)) SWIG_fail;
24145 }
24146 }
24147 {
24148 PyThreadState* __tstate = wxPyBeginAllowThreads();
24149 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24150
24151 wxPyEndAllowThreads(__tstate);
24152 if (PyErr_Occurred()) SWIG_fail;
24153 }
24154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24155 return resultobj;
24156 fail:
24157 return NULL;
24158 }
24159
24160
24161 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24162 PyObject *resultobj;
24163 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24164 PyObject * obj0 = 0 ;
24165 char *kwnames[] = {
24166 (char *) "self", NULL
24167 };
24168
24169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24171 if (SWIG_arg_fail(1)) SWIG_fail;
24172 {
24173 PyThreadState* __tstate = wxPyBeginAllowThreads();
24174 delete arg1;
24175
24176 wxPyEndAllowThreads(__tstate);
24177 if (PyErr_Occurred()) SWIG_fail;
24178 }
24179 Py_INCREF(Py_None); resultobj = Py_None;
24180 return resultobj;
24181 fail:
24182 return NULL;
24183 }
24184
24185
24186 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24187 PyObject *resultobj;
24188 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24189 wxTimeSpan *arg2 = 0 ;
24190 wxTimeSpan *result;
24191 PyObject * obj0 = 0 ;
24192 PyObject * obj1 = 0 ;
24193 char *kwnames[] = {
24194 (char *) "self",(char *) "diff", NULL
24195 };
24196
24197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24199 if (SWIG_arg_fail(1)) SWIG_fail;
24200 {
24201 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24202 if (SWIG_arg_fail(2)) SWIG_fail;
24203 if (arg2 == NULL) {
24204 SWIG_null_ref("wxTimeSpan");
24205 }
24206 if (SWIG_arg_fail(2)) SWIG_fail;
24207 }
24208 {
24209 PyThreadState* __tstate = wxPyBeginAllowThreads();
24210 {
24211 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24212 result = (wxTimeSpan *) &_result_ref;
24213 }
24214
24215 wxPyEndAllowThreads(__tstate);
24216 if (PyErr_Occurred()) SWIG_fail;
24217 }
24218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24219 return resultobj;
24220 fail:
24221 return NULL;
24222 }
24223
24224
24225 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24226 PyObject *resultobj;
24227 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24228 wxTimeSpan *arg2 = 0 ;
24229 wxTimeSpan *result;
24230 PyObject * obj0 = 0 ;
24231 PyObject * obj1 = 0 ;
24232 char *kwnames[] = {
24233 (char *) "self",(char *) "diff", NULL
24234 };
24235
24236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24238 if (SWIG_arg_fail(1)) SWIG_fail;
24239 {
24240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24241 if (SWIG_arg_fail(2)) SWIG_fail;
24242 if (arg2 == NULL) {
24243 SWIG_null_ref("wxTimeSpan");
24244 }
24245 if (SWIG_arg_fail(2)) SWIG_fail;
24246 }
24247 {
24248 PyThreadState* __tstate = wxPyBeginAllowThreads();
24249 {
24250 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24251 result = (wxTimeSpan *) &_result_ref;
24252 }
24253
24254 wxPyEndAllowThreads(__tstate);
24255 if (PyErr_Occurred()) SWIG_fail;
24256 }
24257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24258 return resultobj;
24259 fail:
24260 return NULL;
24261 }
24262
24263
24264 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24265 PyObject *resultobj;
24266 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24267 int arg2 ;
24268 wxTimeSpan *result;
24269 PyObject * obj0 = 0 ;
24270 PyObject * obj1 = 0 ;
24271 char *kwnames[] = {
24272 (char *) "self",(char *) "n", NULL
24273 };
24274
24275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24277 if (SWIG_arg_fail(1)) SWIG_fail;
24278 {
24279 arg2 = (int)(SWIG_As_int(obj1));
24280 if (SWIG_arg_fail(2)) SWIG_fail;
24281 }
24282 {
24283 PyThreadState* __tstate = wxPyBeginAllowThreads();
24284 {
24285 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24286 result = (wxTimeSpan *) &_result_ref;
24287 }
24288
24289 wxPyEndAllowThreads(__tstate);
24290 if (PyErr_Occurred()) SWIG_fail;
24291 }
24292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24293 return resultobj;
24294 fail:
24295 return NULL;
24296 }
24297
24298
24299 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24300 PyObject *resultobj;
24301 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24302 wxTimeSpan *result;
24303 PyObject * obj0 = 0 ;
24304 char *kwnames[] = {
24305 (char *) "self", NULL
24306 };
24307
24308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24310 if (SWIG_arg_fail(1)) SWIG_fail;
24311 {
24312 PyThreadState* __tstate = wxPyBeginAllowThreads();
24313 {
24314 wxTimeSpan &_result_ref = (arg1)->Neg();
24315 result = (wxTimeSpan *) &_result_ref;
24316 }
24317
24318 wxPyEndAllowThreads(__tstate);
24319 if (PyErr_Occurred()) SWIG_fail;
24320 }
24321 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24322 return resultobj;
24323 fail:
24324 return NULL;
24325 }
24326
24327
24328 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24329 PyObject *resultobj;
24330 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24331 wxTimeSpan result;
24332 PyObject * obj0 = 0 ;
24333 char *kwnames[] = {
24334 (char *) "self", NULL
24335 };
24336
24337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24339 if (SWIG_arg_fail(1)) SWIG_fail;
24340 {
24341 PyThreadState* __tstate = wxPyBeginAllowThreads();
24342 result = ((wxTimeSpan const *)arg1)->Abs();
24343
24344 wxPyEndAllowThreads(__tstate);
24345 if (PyErr_Occurred()) SWIG_fail;
24346 }
24347 {
24348 wxTimeSpan * resultptr;
24349 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24350 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24351 }
24352 return resultobj;
24353 fail:
24354 return NULL;
24355 }
24356
24357
24358 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24359 PyObject *resultobj;
24360 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24361 wxTimeSpan *arg2 = 0 ;
24362 wxTimeSpan *result;
24363 PyObject * obj0 = 0 ;
24364 PyObject * obj1 = 0 ;
24365 char *kwnames[] = {
24366 (char *) "self",(char *) "diff", NULL
24367 };
24368
24369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24371 if (SWIG_arg_fail(1)) SWIG_fail;
24372 {
24373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24374 if (SWIG_arg_fail(2)) SWIG_fail;
24375 if (arg2 == NULL) {
24376 SWIG_null_ref("wxTimeSpan");
24377 }
24378 if (SWIG_arg_fail(2)) SWIG_fail;
24379 }
24380 {
24381 PyThreadState* __tstate = wxPyBeginAllowThreads();
24382 {
24383 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24384 result = (wxTimeSpan *) &_result_ref;
24385 }
24386
24387 wxPyEndAllowThreads(__tstate);
24388 if (PyErr_Occurred()) SWIG_fail;
24389 }
24390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24391 return resultobj;
24392 fail:
24393 return NULL;
24394 }
24395
24396
24397 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24398 PyObject *resultobj;
24399 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24400 wxTimeSpan *arg2 = 0 ;
24401 wxTimeSpan *result;
24402 PyObject * obj0 = 0 ;
24403 PyObject * obj1 = 0 ;
24404 char *kwnames[] = {
24405 (char *) "self",(char *) "diff", NULL
24406 };
24407
24408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24410 if (SWIG_arg_fail(1)) SWIG_fail;
24411 {
24412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24413 if (SWIG_arg_fail(2)) SWIG_fail;
24414 if (arg2 == NULL) {
24415 SWIG_null_ref("wxTimeSpan");
24416 }
24417 if (SWIG_arg_fail(2)) SWIG_fail;
24418 }
24419 {
24420 PyThreadState* __tstate = wxPyBeginAllowThreads();
24421 {
24422 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24423 result = (wxTimeSpan *) &_result_ref;
24424 }
24425
24426 wxPyEndAllowThreads(__tstate);
24427 if (PyErr_Occurred()) SWIG_fail;
24428 }
24429 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24430 return resultobj;
24431 fail:
24432 return NULL;
24433 }
24434
24435
24436 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24437 PyObject *resultobj;
24438 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24439 int arg2 ;
24440 wxTimeSpan *result;
24441 PyObject * obj0 = 0 ;
24442 PyObject * obj1 = 0 ;
24443 char *kwnames[] = {
24444 (char *) "self",(char *) "n", NULL
24445 };
24446
24447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24449 if (SWIG_arg_fail(1)) SWIG_fail;
24450 {
24451 arg2 = (int)(SWIG_As_int(obj1));
24452 if (SWIG_arg_fail(2)) SWIG_fail;
24453 }
24454 {
24455 PyThreadState* __tstate = wxPyBeginAllowThreads();
24456 {
24457 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24458 result = (wxTimeSpan *) &_result_ref;
24459 }
24460
24461 wxPyEndAllowThreads(__tstate);
24462 if (PyErr_Occurred()) SWIG_fail;
24463 }
24464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24465 return resultobj;
24466 fail:
24467 return NULL;
24468 }
24469
24470
24471 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24472 PyObject *resultobj;
24473 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24474 wxTimeSpan *result;
24475 PyObject * obj0 = 0 ;
24476 char *kwnames[] = {
24477 (char *) "self", NULL
24478 };
24479
24480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24482 if (SWIG_arg_fail(1)) SWIG_fail;
24483 {
24484 PyThreadState* __tstate = wxPyBeginAllowThreads();
24485 {
24486 wxTimeSpan &_result_ref = (arg1)->operator -();
24487 result = (wxTimeSpan *) &_result_ref;
24488 }
24489
24490 wxPyEndAllowThreads(__tstate);
24491 if (PyErr_Occurred()) SWIG_fail;
24492 }
24493 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24494 return resultobj;
24495 fail:
24496 return NULL;
24497 }
24498
24499
24500 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24501 PyObject *resultobj;
24502 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24503 wxTimeSpan *arg2 = 0 ;
24504 wxTimeSpan result;
24505 PyObject * obj0 = 0 ;
24506 PyObject * obj1 = 0 ;
24507 char *kwnames[] = {
24508 (char *) "self",(char *) "other", NULL
24509 };
24510
24511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24513 if (SWIG_arg_fail(1)) SWIG_fail;
24514 {
24515 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24516 if (SWIG_arg_fail(2)) SWIG_fail;
24517 if (arg2 == NULL) {
24518 SWIG_null_ref("wxTimeSpan");
24519 }
24520 if (SWIG_arg_fail(2)) SWIG_fail;
24521 }
24522 {
24523 PyThreadState* __tstate = wxPyBeginAllowThreads();
24524 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24525
24526 wxPyEndAllowThreads(__tstate);
24527 if (PyErr_Occurred()) SWIG_fail;
24528 }
24529 {
24530 wxTimeSpan * resultptr;
24531 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24532 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24533 }
24534 return resultobj;
24535 fail:
24536 return NULL;
24537 }
24538
24539
24540 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24541 PyObject *resultobj;
24542 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24543 wxTimeSpan *arg2 = 0 ;
24544 wxTimeSpan result;
24545 PyObject * obj0 = 0 ;
24546 PyObject * obj1 = 0 ;
24547 char *kwnames[] = {
24548 (char *) "self",(char *) "other", NULL
24549 };
24550
24551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24553 if (SWIG_arg_fail(1)) SWIG_fail;
24554 {
24555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24556 if (SWIG_arg_fail(2)) SWIG_fail;
24557 if (arg2 == NULL) {
24558 SWIG_null_ref("wxTimeSpan");
24559 }
24560 if (SWIG_arg_fail(2)) SWIG_fail;
24561 }
24562 {
24563 PyThreadState* __tstate = wxPyBeginAllowThreads();
24564 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24565
24566 wxPyEndAllowThreads(__tstate);
24567 if (PyErr_Occurred()) SWIG_fail;
24568 }
24569 {
24570 wxTimeSpan * resultptr;
24571 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24572 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24573 }
24574 return resultobj;
24575 fail:
24576 return NULL;
24577 }
24578
24579
24580 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24581 PyObject *resultobj;
24582 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24583 int arg2 ;
24584 wxTimeSpan result;
24585 PyObject * obj0 = 0 ;
24586 PyObject * obj1 = 0 ;
24587 char *kwnames[] = {
24588 (char *) "self",(char *) "n", NULL
24589 };
24590
24591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24593 if (SWIG_arg_fail(1)) SWIG_fail;
24594 {
24595 arg2 = (int)(SWIG_As_int(obj1));
24596 if (SWIG_arg_fail(2)) SWIG_fail;
24597 }
24598 {
24599 PyThreadState* __tstate = wxPyBeginAllowThreads();
24600 result = wxTimeSpan___mul__(arg1,arg2);
24601
24602 wxPyEndAllowThreads(__tstate);
24603 if (PyErr_Occurred()) SWIG_fail;
24604 }
24605 {
24606 wxTimeSpan * resultptr;
24607 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24608 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24609 }
24610 return resultobj;
24611 fail:
24612 return NULL;
24613 }
24614
24615
24616 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24617 PyObject *resultobj;
24618 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24619 int arg2 ;
24620 wxTimeSpan result;
24621 PyObject * obj0 = 0 ;
24622 PyObject * obj1 = 0 ;
24623 char *kwnames[] = {
24624 (char *) "self",(char *) "n", NULL
24625 };
24626
24627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24629 if (SWIG_arg_fail(1)) SWIG_fail;
24630 {
24631 arg2 = (int)(SWIG_As_int(obj1));
24632 if (SWIG_arg_fail(2)) SWIG_fail;
24633 }
24634 {
24635 PyThreadState* __tstate = wxPyBeginAllowThreads();
24636 result = wxTimeSpan___rmul__(arg1,arg2);
24637
24638 wxPyEndAllowThreads(__tstate);
24639 if (PyErr_Occurred()) SWIG_fail;
24640 }
24641 {
24642 wxTimeSpan * resultptr;
24643 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24645 }
24646 return resultobj;
24647 fail:
24648 return NULL;
24649 }
24650
24651
24652 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24653 PyObject *resultobj;
24654 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24655 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24656 bool result;
24657 PyObject * obj0 = 0 ;
24658 PyObject * obj1 = 0 ;
24659 char *kwnames[] = {
24660 (char *) "self",(char *) "other", NULL
24661 };
24662
24663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24665 if (SWIG_arg_fail(1)) SWIG_fail;
24666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24667 if (SWIG_arg_fail(2)) SWIG_fail;
24668 {
24669 PyThreadState* __tstate = wxPyBeginAllowThreads();
24670 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24671
24672 wxPyEndAllowThreads(__tstate);
24673 if (PyErr_Occurred()) SWIG_fail;
24674 }
24675 {
24676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24677 }
24678 return resultobj;
24679 fail:
24680 return NULL;
24681 }
24682
24683
24684 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24685 PyObject *resultobj;
24686 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24687 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24688 bool result;
24689 PyObject * obj0 = 0 ;
24690 PyObject * obj1 = 0 ;
24691 char *kwnames[] = {
24692 (char *) "self",(char *) "other", NULL
24693 };
24694
24695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24697 if (SWIG_arg_fail(1)) SWIG_fail;
24698 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24699 if (SWIG_arg_fail(2)) SWIG_fail;
24700 {
24701 PyThreadState* __tstate = wxPyBeginAllowThreads();
24702 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24703
24704 wxPyEndAllowThreads(__tstate);
24705 if (PyErr_Occurred()) SWIG_fail;
24706 }
24707 {
24708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24709 }
24710 return resultobj;
24711 fail:
24712 return NULL;
24713 }
24714
24715
24716 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24717 PyObject *resultobj;
24718 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24719 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24720 bool result;
24721 PyObject * obj0 = 0 ;
24722 PyObject * obj1 = 0 ;
24723 char *kwnames[] = {
24724 (char *) "self",(char *) "other", NULL
24725 };
24726
24727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24729 if (SWIG_arg_fail(1)) SWIG_fail;
24730 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24731 if (SWIG_arg_fail(2)) SWIG_fail;
24732 {
24733 PyThreadState* __tstate = wxPyBeginAllowThreads();
24734 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24735
24736 wxPyEndAllowThreads(__tstate);
24737 if (PyErr_Occurred()) SWIG_fail;
24738 }
24739 {
24740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24741 }
24742 return resultobj;
24743 fail:
24744 return NULL;
24745 }
24746
24747
24748 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24749 PyObject *resultobj;
24750 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24751 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24752 bool result;
24753 PyObject * obj0 = 0 ;
24754 PyObject * obj1 = 0 ;
24755 char *kwnames[] = {
24756 (char *) "self",(char *) "other", NULL
24757 };
24758
24759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24761 if (SWIG_arg_fail(1)) SWIG_fail;
24762 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24763 if (SWIG_arg_fail(2)) SWIG_fail;
24764 {
24765 PyThreadState* __tstate = wxPyBeginAllowThreads();
24766 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24767
24768 wxPyEndAllowThreads(__tstate);
24769 if (PyErr_Occurred()) SWIG_fail;
24770 }
24771 {
24772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24773 }
24774 return resultobj;
24775 fail:
24776 return NULL;
24777 }
24778
24779
24780 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24781 PyObject *resultobj;
24782 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24783 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24784 bool result;
24785 PyObject * obj0 = 0 ;
24786 PyObject * obj1 = 0 ;
24787 char *kwnames[] = {
24788 (char *) "self",(char *) "other", NULL
24789 };
24790
24791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24793 if (SWIG_arg_fail(1)) SWIG_fail;
24794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24795 if (SWIG_arg_fail(2)) SWIG_fail;
24796 {
24797 PyThreadState* __tstate = wxPyBeginAllowThreads();
24798 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24799
24800 wxPyEndAllowThreads(__tstate);
24801 if (PyErr_Occurred()) SWIG_fail;
24802 }
24803 {
24804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24805 }
24806 return resultobj;
24807 fail:
24808 return NULL;
24809 }
24810
24811
24812 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24813 PyObject *resultobj;
24814 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24815 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24816 bool result;
24817 PyObject * obj0 = 0 ;
24818 PyObject * obj1 = 0 ;
24819 char *kwnames[] = {
24820 (char *) "self",(char *) "other", NULL
24821 };
24822
24823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24825 if (SWIG_arg_fail(1)) SWIG_fail;
24826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24827 if (SWIG_arg_fail(2)) SWIG_fail;
24828 {
24829 PyThreadState* __tstate = wxPyBeginAllowThreads();
24830 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24831
24832 wxPyEndAllowThreads(__tstate);
24833 if (PyErr_Occurred()) SWIG_fail;
24834 }
24835 {
24836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24837 }
24838 return resultobj;
24839 fail:
24840 return NULL;
24841 }
24842
24843
24844 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24845 PyObject *resultobj;
24846 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24847 bool result;
24848 PyObject * obj0 = 0 ;
24849 char *kwnames[] = {
24850 (char *) "self", NULL
24851 };
24852
24853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24855 if (SWIG_arg_fail(1)) SWIG_fail;
24856 {
24857 PyThreadState* __tstate = wxPyBeginAllowThreads();
24858 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24859
24860 wxPyEndAllowThreads(__tstate);
24861 if (PyErr_Occurred()) SWIG_fail;
24862 }
24863 {
24864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24865 }
24866 return resultobj;
24867 fail:
24868 return NULL;
24869 }
24870
24871
24872 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24873 PyObject *resultobj;
24874 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24875 bool result;
24876 PyObject * obj0 = 0 ;
24877 char *kwnames[] = {
24878 (char *) "self", NULL
24879 };
24880
24881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24883 if (SWIG_arg_fail(1)) SWIG_fail;
24884 {
24885 PyThreadState* __tstate = wxPyBeginAllowThreads();
24886 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24887
24888 wxPyEndAllowThreads(__tstate);
24889 if (PyErr_Occurred()) SWIG_fail;
24890 }
24891 {
24892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24893 }
24894 return resultobj;
24895 fail:
24896 return NULL;
24897 }
24898
24899
24900 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24901 PyObject *resultobj;
24902 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24903 bool result;
24904 PyObject * obj0 = 0 ;
24905 char *kwnames[] = {
24906 (char *) "self", NULL
24907 };
24908
24909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24911 if (SWIG_arg_fail(1)) SWIG_fail;
24912 {
24913 PyThreadState* __tstate = wxPyBeginAllowThreads();
24914 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24915
24916 wxPyEndAllowThreads(__tstate);
24917 if (PyErr_Occurred()) SWIG_fail;
24918 }
24919 {
24920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24921 }
24922 return resultobj;
24923 fail:
24924 return NULL;
24925 }
24926
24927
24928 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj;
24930 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24931 wxTimeSpan *arg2 = 0 ;
24932 bool result;
24933 PyObject * obj0 = 0 ;
24934 PyObject * obj1 = 0 ;
24935 char *kwnames[] = {
24936 (char *) "self",(char *) "ts", NULL
24937 };
24938
24939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24941 if (SWIG_arg_fail(1)) SWIG_fail;
24942 {
24943 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24944 if (SWIG_arg_fail(2)) SWIG_fail;
24945 if (arg2 == NULL) {
24946 SWIG_null_ref("wxTimeSpan");
24947 }
24948 if (SWIG_arg_fail(2)) SWIG_fail;
24949 }
24950 {
24951 PyThreadState* __tstate = wxPyBeginAllowThreads();
24952 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24953
24954 wxPyEndAllowThreads(__tstate);
24955 if (PyErr_Occurred()) SWIG_fail;
24956 }
24957 {
24958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24959 }
24960 return resultobj;
24961 fail:
24962 return NULL;
24963 }
24964
24965
24966 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24967 PyObject *resultobj;
24968 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24969 wxTimeSpan *arg2 = 0 ;
24970 bool result;
24971 PyObject * obj0 = 0 ;
24972 PyObject * obj1 = 0 ;
24973 char *kwnames[] = {
24974 (char *) "self",(char *) "ts", NULL
24975 };
24976
24977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24979 if (SWIG_arg_fail(1)) SWIG_fail;
24980 {
24981 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24982 if (SWIG_arg_fail(2)) SWIG_fail;
24983 if (arg2 == NULL) {
24984 SWIG_null_ref("wxTimeSpan");
24985 }
24986 if (SWIG_arg_fail(2)) SWIG_fail;
24987 }
24988 {
24989 PyThreadState* __tstate = wxPyBeginAllowThreads();
24990 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24991
24992 wxPyEndAllowThreads(__tstate);
24993 if (PyErr_Occurred()) SWIG_fail;
24994 }
24995 {
24996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24997 }
24998 return resultobj;
24999 fail:
25000 return NULL;
25001 }
25002
25003
25004 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25005 PyObject *resultobj;
25006 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25007 wxTimeSpan *arg2 = 0 ;
25008 bool result;
25009 PyObject * obj0 = 0 ;
25010 PyObject * obj1 = 0 ;
25011 char *kwnames[] = {
25012 (char *) "self",(char *) "t", NULL
25013 };
25014
25015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25017 if (SWIG_arg_fail(1)) SWIG_fail;
25018 {
25019 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25020 if (SWIG_arg_fail(2)) SWIG_fail;
25021 if (arg2 == NULL) {
25022 SWIG_null_ref("wxTimeSpan");
25023 }
25024 if (SWIG_arg_fail(2)) SWIG_fail;
25025 }
25026 {
25027 PyThreadState* __tstate = wxPyBeginAllowThreads();
25028 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25029
25030 wxPyEndAllowThreads(__tstate);
25031 if (PyErr_Occurred()) SWIG_fail;
25032 }
25033 {
25034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25035 }
25036 return resultobj;
25037 fail:
25038 return NULL;
25039 }
25040
25041
25042 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25043 PyObject *resultobj;
25044 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25045 int result;
25046 PyObject * obj0 = 0 ;
25047 char *kwnames[] = {
25048 (char *) "self", NULL
25049 };
25050
25051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25053 if (SWIG_arg_fail(1)) SWIG_fail;
25054 {
25055 PyThreadState* __tstate = wxPyBeginAllowThreads();
25056 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25057
25058 wxPyEndAllowThreads(__tstate);
25059 if (PyErr_Occurred()) SWIG_fail;
25060 }
25061 {
25062 resultobj = SWIG_From_int((int)(result));
25063 }
25064 return resultobj;
25065 fail:
25066 return NULL;
25067 }
25068
25069
25070 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25071 PyObject *resultobj;
25072 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25073 int result;
25074 PyObject * obj0 = 0 ;
25075 char *kwnames[] = {
25076 (char *) "self", NULL
25077 };
25078
25079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25081 if (SWIG_arg_fail(1)) SWIG_fail;
25082 {
25083 PyThreadState* __tstate = wxPyBeginAllowThreads();
25084 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25085
25086 wxPyEndAllowThreads(__tstate);
25087 if (PyErr_Occurred()) SWIG_fail;
25088 }
25089 {
25090 resultobj = SWIG_From_int((int)(result));
25091 }
25092 return resultobj;
25093 fail:
25094 return NULL;
25095 }
25096
25097
25098 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25099 PyObject *resultobj;
25100 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25101 int result;
25102 PyObject * obj0 = 0 ;
25103 char *kwnames[] = {
25104 (char *) "self", NULL
25105 };
25106
25107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25109 if (SWIG_arg_fail(1)) SWIG_fail;
25110 {
25111 PyThreadState* __tstate = wxPyBeginAllowThreads();
25112 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25113
25114 wxPyEndAllowThreads(__tstate);
25115 if (PyErr_Occurred()) SWIG_fail;
25116 }
25117 {
25118 resultobj = SWIG_From_int((int)(result));
25119 }
25120 return resultobj;
25121 fail:
25122 return NULL;
25123 }
25124
25125
25126 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25127 PyObject *resultobj;
25128 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25129 int result;
25130 PyObject * obj0 = 0 ;
25131 char *kwnames[] = {
25132 (char *) "self", NULL
25133 };
25134
25135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25137 if (SWIG_arg_fail(1)) SWIG_fail;
25138 {
25139 PyThreadState* __tstate = wxPyBeginAllowThreads();
25140 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25141
25142 wxPyEndAllowThreads(__tstate);
25143 if (PyErr_Occurred()) SWIG_fail;
25144 }
25145 {
25146 resultobj = SWIG_From_int((int)(result));
25147 }
25148 return resultobj;
25149 fail:
25150 return NULL;
25151 }
25152
25153
25154 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25155 PyObject *resultobj;
25156 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25157 wxLongLong result;
25158 PyObject * obj0 = 0 ;
25159 char *kwnames[] = {
25160 (char *) "self", NULL
25161 };
25162
25163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25165 if (SWIG_arg_fail(1)) SWIG_fail;
25166 {
25167 PyThreadState* __tstate = wxPyBeginAllowThreads();
25168 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25169
25170 wxPyEndAllowThreads(__tstate);
25171 if (PyErr_Occurred()) SWIG_fail;
25172 }
25173 {
25174 PyObject *hi, *lo, *shifter, *shifted;
25175 hi = PyLong_FromLong( (&result)->GetHi() );
25176 lo = PyLong_FromLong( (&result)->GetLo() );
25177 shifter = PyLong_FromLong(32);
25178 shifted = PyNumber_Lshift(hi, shifter);
25179 resultobj = PyNumber_Or(shifted, lo);
25180 Py_DECREF(hi);
25181 Py_DECREF(lo);
25182 Py_DECREF(shifter);
25183 Py_DECREF(shifted);
25184 }
25185 return resultobj;
25186 fail:
25187 return NULL;
25188 }
25189
25190
25191 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25192 PyObject *resultobj;
25193 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25194 wxLongLong result;
25195 PyObject * obj0 = 0 ;
25196 char *kwnames[] = {
25197 (char *) "self", NULL
25198 };
25199
25200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25202 if (SWIG_arg_fail(1)) SWIG_fail;
25203 {
25204 PyThreadState* __tstate = wxPyBeginAllowThreads();
25205 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25206
25207 wxPyEndAllowThreads(__tstate);
25208 if (PyErr_Occurred()) SWIG_fail;
25209 }
25210 {
25211 PyObject *hi, *lo, *shifter, *shifted;
25212 hi = PyLong_FromLong( (&result)->GetHi() );
25213 lo = PyLong_FromLong( (&result)->GetLo() );
25214 shifter = PyLong_FromLong(32);
25215 shifted = PyNumber_Lshift(hi, shifter);
25216 resultobj = PyNumber_Or(shifted, lo);
25217 Py_DECREF(hi);
25218 Py_DECREF(lo);
25219 Py_DECREF(shifter);
25220 Py_DECREF(shifted);
25221 }
25222 return resultobj;
25223 fail:
25224 return NULL;
25225 }
25226
25227
25228 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25229 PyObject *resultobj;
25230 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25231 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25232 wxString *arg2 = (wxString *) &arg2_defvalue ;
25233 wxString result;
25234 bool temp2 = false ;
25235 PyObject * obj0 = 0 ;
25236 PyObject * obj1 = 0 ;
25237 char *kwnames[] = {
25238 (char *) "self",(char *) "format", NULL
25239 };
25240
25241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25243 if (SWIG_arg_fail(1)) SWIG_fail;
25244 if (obj1) {
25245 {
25246 arg2 = wxString_in_helper(obj1);
25247 if (arg2 == NULL) SWIG_fail;
25248 temp2 = true;
25249 }
25250 }
25251 {
25252 PyThreadState* __tstate = wxPyBeginAllowThreads();
25253 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25254
25255 wxPyEndAllowThreads(__tstate);
25256 if (PyErr_Occurred()) SWIG_fail;
25257 }
25258 {
25259 #if wxUSE_UNICODE
25260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25261 #else
25262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25263 #endif
25264 }
25265 {
25266 if (temp2)
25267 delete arg2;
25268 }
25269 return resultobj;
25270 fail:
25271 {
25272 if (temp2)
25273 delete arg2;
25274 }
25275 return NULL;
25276 }
25277
25278
25279 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25280 PyObject *obj;
25281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25282 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25283 Py_INCREF(obj);
25284 return Py_BuildValue((char *)"");
25285 }
25286 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25287 PyObject *resultobj;
25288 int arg1 = (int) 0 ;
25289 int arg2 = (int) 0 ;
25290 int arg3 = (int) 0 ;
25291 int arg4 = (int) 0 ;
25292 wxDateSpan *result;
25293 PyObject * obj0 = 0 ;
25294 PyObject * obj1 = 0 ;
25295 PyObject * obj2 = 0 ;
25296 PyObject * obj3 = 0 ;
25297 char *kwnames[] = {
25298 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25299 };
25300
25301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25302 if (obj0) {
25303 {
25304 arg1 = (int)(SWIG_As_int(obj0));
25305 if (SWIG_arg_fail(1)) SWIG_fail;
25306 }
25307 }
25308 if (obj1) {
25309 {
25310 arg2 = (int)(SWIG_As_int(obj1));
25311 if (SWIG_arg_fail(2)) SWIG_fail;
25312 }
25313 }
25314 if (obj2) {
25315 {
25316 arg3 = (int)(SWIG_As_int(obj2));
25317 if (SWIG_arg_fail(3)) SWIG_fail;
25318 }
25319 }
25320 if (obj3) {
25321 {
25322 arg4 = (int)(SWIG_As_int(obj3));
25323 if (SWIG_arg_fail(4)) SWIG_fail;
25324 }
25325 }
25326 {
25327 PyThreadState* __tstate = wxPyBeginAllowThreads();
25328 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25329
25330 wxPyEndAllowThreads(__tstate);
25331 if (PyErr_Occurred()) SWIG_fail;
25332 }
25333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25334 return resultobj;
25335 fail:
25336 return NULL;
25337 }
25338
25339
25340 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25341 PyObject *resultobj;
25342 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25343 PyObject * obj0 = 0 ;
25344 char *kwnames[] = {
25345 (char *) "self", NULL
25346 };
25347
25348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25350 if (SWIG_arg_fail(1)) SWIG_fail;
25351 {
25352 PyThreadState* __tstate = wxPyBeginAllowThreads();
25353 delete arg1;
25354
25355 wxPyEndAllowThreads(__tstate);
25356 if (PyErr_Occurred()) SWIG_fail;
25357 }
25358 Py_INCREF(Py_None); resultobj = Py_None;
25359 return resultobj;
25360 fail:
25361 return NULL;
25362 }
25363
25364
25365 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25366 PyObject *resultobj;
25367 int arg1 ;
25368 wxDateSpan result;
25369 PyObject * obj0 = 0 ;
25370 char *kwnames[] = {
25371 (char *) "days", NULL
25372 };
25373
25374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25375 {
25376 arg1 = (int)(SWIG_As_int(obj0));
25377 if (SWIG_arg_fail(1)) SWIG_fail;
25378 }
25379 {
25380 PyThreadState* __tstate = wxPyBeginAllowThreads();
25381 result = wxDateSpan::Days(arg1);
25382
25383 wxPyEndAllowThreads(__tstate);
25384 if (PyErr_Occurred()) SWIG_fail;
25385 }
25386 {
25387 wxDateSpan * resultptr;
25388 resultptr = new wxDateSpan((wxDateSpan &)(result));
25389 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25390 }
25391 return resultobj;
25392 fail:
25393 return NULL;
25394 }
25395
25396
25397 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25398 PyObject *resultobj;
25399 wxDateSpan result;
25400 char *kwnames[] = {
25401 NULL
25402 };
25403
25404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25405 {
25406 PyThreadState* __tstate = wxPyBeginAllowThreads();
25407 result = wxDateSpan::Day();
25408
25409 wxPyEndAllowThreads(__tstate);
25410 if (PyErr_Occurred()) SWIG_fail;
25411 }
25412 {
25413 wxDateSpan * resultptr;
25414 resultptr = new wxDateSpan((wxDateSpan &)(result));
25415 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25416 }
25417 return resultobj;
25418 fail:
25419 return NULL;
25420 }
25421
25422
25423 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25424 PyObject *resultobj;
25425 int arg1 ;
25426 wxDateSpan result;
25427 PyObject * obj0 = 0 ;
25428 char *kwnames[] = {
25429 (char *) "weeks", NULL
25430 };
25431
25432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25433 {
25434 arg1 = (int)(SWIG_As_int(obj0));
25435 if (SWIG_arg_fail(1)) SWIG_fail;
25436 }
25437 {
25438 PyThreadState* __tstate = wxPyBeginAllowThreads();
25439 result = wxDateSpan::Weeks(arg1);
25440
25441 wxPyEndAllowThreads(__tstate);
25442 if (PyErr_Occurred()) SWIG_fail;
25443 }
25444 {
25445 wxDateSpan * resultptr;
25446 resultptr = new wxDateSpan((wxDateSpan &)(result));
25447 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25448 }
25449 return resultobj;
25450 fail:
25451 return NULL;
25452 }
25453
25454
25455 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25456 PyObject *resultobj;
25457 wxDateSpan result;
25458 char *kwnames[] = {
25459 NULL
25460 };
25461
25462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25463 {
25464 PyThreadState* __tstate = wxPyBeginAllowThreads();
25465 result = wxDateSpan::Week();
25466
25467 wxPyEndAllowThreads(__tstate);
25468 if (PyErr_Occurred()) SWIG_fail;
25469 }
25470 {
25471 wxDateSpan * resultptr;
25472 resultptr = new wxDateSpan((wxDateSpan &)(result));
25473 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25474 }
25475 return resultobj;
25476 fail:
25477 return NULL;
25478 }
25479
25480
25481 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25482 PyObject *resultobj;
25483 int arg1 ;
25484 wxDateSpan result;
25485 PyObject * obj0 = 0 ;
25486 char *kwnames[] = {
25487 (char *) "mon", NULL
25488 };
25489
25490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25491 {
25492 arg1 = (int)(SWIG_As_int(obj0));
25493 if (SWIG_arg_fail(1)) SWIG_fail;
25494 }
25495 {
25496 PyThreadState* __tstate = wxPyBeginAllowThreads();
25497 result = wxDateSpan::Months(arg1);
25498
25499 wxPyEndAllowThreads(__tstate);
25500 if (PyErr_Occurred()) SWIG_fail;
25501 }
25502 {
25503 wxDateSpan * resultptr;
25504 resultptr = new wxDateSpan((wxDateSpan &)(result));
25505 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25506 }
25507 return resultobj;
25508 fail:
25509 return NULL;
25510 }
25511
25512
25513 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25514 PyObject *resultobj;
25515 wxDateSpan result;
25516 char *kwnames[] = {
25517 NULL
25518 };
25519
25520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25521 {
25522 PyThreadState* __tstate = wxPyBeginAllowThreads();
25523 result = wxDateSpan::Month();
25524
25525 wxPyEndAllowThreads(__tstate);
25526 if (PyErr_Occurred()) SWIG_fail;
25527 }
25528 {
25529 wxDateSpan * resultptr;
25530 resultptr = new wxDateSpan((wxDateSpan &)(result));
25531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25532 }
25533 return resultobj;
25534 fail:
25535 return NULL;
25536 }
25537
25538
25539 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25540 PyObject *resultobj;
25541 int arg1 ;
25542 wxDateSpan result;
25543 PyObject * obj0 = 0 ;
25544 char *kwnames[] = {
25545 (char *) "years", NULL
25546 };
25547
25548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25549 {
25550 arg1 = (int)(SWIG_As_int(obj0));
25551 if (SWIG_arg_fail(1)) SWIG_fail;
25552 }
25553 {
25554 PyThreadState* __tstate = wxPyBeginAllowThreads();
25555 result = wxDateSpan::Years(arg1);
25556
25557 wxPyEndAllowThreads(__tstate);
25558 if (PyErr_Occurred()) SWIG_fail;
25559 }
25560 {
25561 wxDateSpan * resultptr;
25562 resultptr = new wxDateSpan((wxDateSpan &)(result));
25563 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25564 }
25565 return resultobj;
25566 fail:
25567 return NULL;
25568 }
25569
25570
25571 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25572 PyObject *resultobj;
25573 wxDateSpan result;
25574 char *kwnames[] = {
25575 NULL
25576 };
25577
25578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25579 {
25580 PyThreadState* __tstate = wxPyBeginAllowThreads();
25581 result = wxDateSpan::Year();
25582
25583 wxPyEndAllowThreads(__tstate);
25584 if (PyErr_Occurred()) SWIG_fail;
25585 }
25586 {
25587 wxDateSpan * resultptr;
25588 resultptr = new wxDateSpan((wxDateSpan &)(result));
25589 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25590 }
25591 return resultobj;
25592 fail:
25593 return NULL;
25594 }
25595
25596
25597 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25598 PyObject *resultobj;
25599 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25600 int arg2 ;
25601 wxDateSpan *result;
25602 PyObject * obj0 = 0 ;
25603 PyObject * obj1 = 0 ;
25604 char *kwnames[] = {
25605 (char *) "self",(char *) "n", NULL
25606 };
25607
25608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25610 if (SWIG_arg_fail(1)) SWIG_fail;
25611 {
25612 arg2 = (int)(SWIG_As_int(obj1));
25613 if (SWIG_arg_fail(2)) SWIG_fail;
25614 }
25615 {
25616 PyThreadState* __tstate = wxPyBeginAllowThreads();
25617 {
25618 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25619 result = (wxDateSpan *) &_result_ref;
25620 }
25621
25622 wxPyEndAllowThreads(__tstate);
25623 if (PyErr_Occurred()) SWIG_fail;
25624 }
25625 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25626 return resultobj;
25627 fail:
25628 return NULL;
25629 }
25630
25631
25632 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25633 PyObject *resultobj;
25634 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25635 int arg2 ;
25636 wxDateSpan *result;
25637 PyObject * obj0 = 0 ;
25638 PyObject * obj1 = 0 ;
25639 char *kwnames[] = {
25640 (char *) "self",(char *) "n", NULL
25641 };
25642
25643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25645 if (SWIG_arg_fail(1)) SWIG_fail;
25646 {
25647 arg2 = (int)(SWIG_As_int(obj1));
25648 if (SWIG_arg_fail(2)) SWIG_fail;
25649 }
25650 {
25651 PyThreadState* __tstate = wxPyBeginAllowThreads();
25652 {
25653 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25654 result = (wxDateSpan *) &_result_ref;
25655 }
25656
25657 wxPyEndAllowThreads(__tstate);
25658 if (PyErr_Occurred()) SWIG_fail;
25659 }
25660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25661 return resultobj;
25662 fail:
25663 return NULL;
25664 }
25665
25666
25667 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25668 PyObject *resultobj;
25669 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25670 int arg2 ;
25671 wxDateSpan *result;
25672 PyObject * obj0 = 0 ;
25673 PyObject * obj1 = 0 ;
25674 char *kwnames[] = {
25675 (char *) "self",(char *) "n", NULL
25676 };
25677
25678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25680 if (SWIG_arg_fail(1)) SWIG_fail;
25681 {
25682 arg2 = (int)(SWIG_As_int(obj1));
25683 if (SWIG_arg_fail(2)) SWIG_fail;
25684 }
25685 {
25686 PyThreadState* __tstate = wxPyBeginAllowThreads();
25687 {
25688 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25689 result = (wxDateSpan *) &_result_ref;
25690 }
25691
25692 wxPyEndAllowThreads(__tstate);
25693 if (PyErr_Occurred()) SWIG_fail;
25694 }
25695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25696 return resultobj;
25697 fail:
25698 return NULL;
25699 }
25700
25701
25702 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25703 PyObject *resultobj;
25704 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25705 int arg2 ;
25706 wxDateSpan *result;
25707 PyObject * obj0 = 0 ;
25708 PyObject * obj1 = 0 ;
25709 char *kwnames[] = {
25710 (char *) "self",(char *) "n", NULL
25711 };
25712
25713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25715 if (SWIG_arg_fail(1)) SWIG_fail;
25716 {
25717 arg2 = (int)(SWIG_As_int(obj1));
25718 if (SWIG_arg_fail(2)) SWIG_fail;
25719 }
25720 {
25721 PyThreadState* __tstate = wxPyBeginAllowThreads();
25722 {
25723 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25724 result = (wxDateSpan *) &_result_ref;
25725 }
25726
25727 wxPyEndAllowThreads(__tstate);
25728 if (PyErr_Occurred()) SWIG_fail;
25729 }
25730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25731 return resultobj;
25732 fail:
25733 return NULL;
25734 }
25735
25736
25737 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25738 PyObject *resultobj;
25739 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25740 int result;
25741 PyObject * obj0 = 0 ;
25742 char *kwnames[] = {
25743 (char *) "self", NULL
25744 };
25745
25746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25748 if (SWIG_arg_fail(1)) SWIG_fail;
25749 {
25750 PyThreadState* __tstate = wxPyBeginAllowThreads();
25751 result = (int)((wxDateSpan const *)arg1)->GetYears();
25752
25753 wxPyEndAllowThreads(__tstate);
25754 if (PyErr_Occurred()) SWIG_fail;
25755 }
25756 {
25757 resultobj = SWIG_From_int((int)(result));
25758 }
25759 return resultobj;
25760 fail:
25761 return NULL;
25762 }
25763
25764
25765 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25766 PyObject *resultobj;
25767 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25768 int result;
25769 PyObject * obj0 = 0 ;
25770 char *kwnames[] = {
25771 (char *) "self", NULL
25772 };
25773
25774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25776 if (SWIG_arg_fail(1)) SWIG_fail;
25777 {
25778 PyThreadState* __tstate = wxPyBeginAllowThreads();
25779 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25780
25781 wxPyEndAllowThreads(__tstate);
25782 if (PyErr_Occurred()) SWIG_fail;
25783 }
25784 {
25785 resultobj = SWIG_From_int((int)(result));
25786 }
25787 return resultobj;
25788 fail:
25789 return NULL;
25790 }
25791
25792
25793 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25794 PyObject *resultobj;
25795 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25796 int result;
25797 PyObject * obj0 = 0 ;
25798 char *kwnames[] = {
25799 (char *) "self", NULL
25800 };
25801
25802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25804 if (SWIG_arg_fail(1)) SWIG_fail;
25805 {
25806 PyThreadState* __tstate = wxPyBeginAllowThreads();
25807 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25808
25809 wxPyEndAllowThreads(__tstate);
25810 if (PyErr_Occurred()) SWIG_fail;
25811 }
25812 {
25813 resultobj = SWIG_From_int((int)(result));
25814 }
25815 return resultobj;
25816 fail:
25817 return NULL;
25818 }
25819
25820
25821 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25822 PyObject *resultobj;
25823 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25824 int result;
25825 PyObject * obj0 = 0 ;
25826 char *kwnames[] = {
25827 (char *) "self", NULL
25828 };
25829
25830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25832 if (SWIG_arg_fail(1)) SWIG_fail;
25833 {
25834 PyThreadState* __tstate = wxPyBeginAllowThreads();
25835 result = (int)((wxDateSpan const *)arg1)->GetDays();
25836
25837 wxPyEndAllowThreads(__tstate);
25838 if (PyErr_Occurred()) SWIG_fail;
25839 }
25840 {
25841 resultobj = SWIG_From_int((int)(result));
25842 }
25843 return resultobj;
25844 fail:
25845 return NULL;
25846 }
25847
25848
25849 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25850 PyObject *resultobj;
25851 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25852 int result;
25853 PyObject * obj0 = 0 ;
25854 char *kwnames[] = {
25855 (char *) "self", NULL
25856 };
25857
25858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25860 if (SWIG_arg_fail(1)) SWIG_fail;
25861 {
25862 PyThreadState* __tstate = wxPyBeginAllowThreads();
25863 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25864
25865 wxPyEndAllowThreads(__tstate);
25866 if (PyErr_Occurred()) SWIG_fail;
25867 }
25868 {
25869 resultobj = SWIG_From_int((int)(result));
25870 }
25871 return resultobj;
25872 fail:
25873 return NULL;
25874 }
25875
25876
25877 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25878 PyObject *resultobj;
25879 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25880 wxDateSpan *arg2 = 0 ;
25881 wxDateSpan *result;
25882 PyObject * obj0 = 0 ;
25883 PyObject * obj1 = 0 ;
25884 char *kwnames[] = {
25885 (char *) "self",(char *) "other", NULL
25886 };
25887
25888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25890 if (SWIG_arg_fail(1)) SWIG_fail;
25891 {
25892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25893 if (SWIG_arg_fail(2)) SWIG_fail;
25894 if (arg2 == NULL) {
25895 SWIG_null_ref("wxDateSpan");
25896 }
25897 if (SWIG_arg_fail(2)) SWIG_fail;
25898 }
25899 {
25900 PyThreadState* __tstate = wxPyBeginAllowThreads();
25901 {
25902 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25903 result = (wxDateSpan *) &_result_ref;
25904 }
25905
25906 wxPyEndAllowThreads(__tstate);
25907 if (PyErr_Occurred()) SWIG_fail;
25908 }
25909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25910 return resultobj;
25911 fail:
25912 return NULL;
25913 }
25914
25915
25916 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25917 PyObject *resultobj;
25918 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25919 wxDateSpan *arg2 = 0 ;
25920 wxDateSpan *result;
25921 PyObject * obj0 = 0 ;
25922 PyObject * obj1 = 0 ;
25923 char *kwnames[] = {
25924 (char *) "self",(char *) "other", NULL
25925 };
25926
25927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25929 if (SWIG_arg_fail(1)) SWIG_fail;
25930 {
25931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25932 if (SWIG_arg_fail(2)) SWIG_fail;
25933 if (arg2 == NULL) {
25934 SWIG_null_ref("wxDateSpan");
25935 }
25936 if (SWIG_arg_fail(2)) SWIG_fail;
25937 }
25938 {
25939 PyThreadState* __tstate = wxPyBeginAllowThreads();
25940 {
25941 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25942 result = (wxDateSpan *) &_result_ref;
25943 }
25944
25945 wxPyEndAllowThreads(__tstate);
25946 if (PyErr_Occurred()) SWIG_fail;
25947 }
25948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25949 return resultobj;
25950 fail:
25951 return NULL;
25952 }
25953
25954
25955 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25956 PyObject *resultobj;
25957 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25958 wxDateSpan *result;
25959 PyObject * obj0 = 0 ;
25960 char *kwnames[] = {
25961 (char *) "self", NULL
25962 };
25963
25964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25966 if (SWIG_arg_fail(1)) SWIG_fail;
25967 {
25968 PyThreadState* __tstate = wxPyBeginAllowThreads();
25969 {
25970 wxDateSpan &_result_ref = (arg1)->Neg();
25971 result = (wxDateSpan *) &_result_ref;
25972 }
25973
25974 wxPyEndAllowThreads(__tstate);
25975 if (PyErr_Occurred()) SWIG_fail;
25976 }
25977 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25978 return resultobj;
25979 fail:
25980 return NULL;
25981 }
25982
25983
25984 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25985 PyObject *resultobj;
25986 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25987 int arg2 ;
25988 wxDateSpan *result;
25989 PyObject * obj0 = 0 ;
25990 PyObject * obj1 = 0 ;
25991 char *kwnames[] = {
25992 (char *) "self",(char *) "factor", NULL
25993 };
25994
25995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25997 if (SWIG_arg_fail(1)) SWIG_fail;
25998 {
25999 arg2 = (int)(SWIG_As_int(obj1));
26000 if (SWIG_arg_fail(2)) SWIG_fail;
26001 }
26002 {
26003 PyThreadState* __tstate = wxPyBeginAllowThreads();
26004 {
26005 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26006 result = (wxDateSpan *) &_result_ref;
26007 }
26008
26009 wxPyEndAllowThreads(__tstate);
26010 if (PyErr_Occurred()) SWIG_fail;
26011 }
26012 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26013 return resultobj;
26014 fail:
26015 return NULL;
26016 }
26017
26018
26019 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26020 PyObject *resultobj;
26021 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26022 wxDateSpan *arg2 = 0 ;
26023 wxDateSpan *result;
26024 PyObject * obj0 = 0 ;
26025 PyObject * obj1 = 0 ;
26026 char *kwnames[] = {
26027 (char *) "self",(char *) "other", NULL
26028 };
26029
26030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26032 if (SWIG_arg_fail(1)) SWIG_fail;
26033 {
26034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26035 if (SWIG_arg_fail(2)) SWIG_fail;
26036 if (arg2 == NULL) {
26037 SWIG_null_ref("wxDateSpan");
26038 }
26039 if (SWIG_arg_fail(2)) SWIG_fail;
26040 }
26041 {
26042 PyThreadState* __tstate = wxPyBeginAllowThreads();
26043 {
26044 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26045 result = (wxDateSpan *) &_result_ref;
26046 }
26047
26048 wxPyEndAllowThreads(__tstate);
26049 if (PyErr_Occurred()) SWIG_fail;
26050 }
26051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26052 return resultobj;
26053 fail:
26054 return NULL;
26055 }
26056
26057
26058 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26059 PyObject *resultobj;
26060 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26061 wxDateSpan *arg2 = 0 ;
26062 wxDateSpan *result;
26063 PyObject * obj0 = 0 ;
26064 PyObject * obj1 = 0 ;
26065 char *kwnames[] = {
26066 (char *) "self",(char *) "other", NULL
26067 };
26068
26069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26071 if (SWIG_arg_fail(1)) SWIG_fail;
26072 {
26073 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26074 if (SWIG_arg_fail(2)) SWIG_fail;
26075 if (arg2 == NULL) {
26076 SWIG_null_ref("wxDateSpan");
26077 }
26078 if (SWIG_arg_fail(2)) SWIG_fail;
26079 }
26080 {
26081 PyThreadState* __tstate = wxPyBeginAllowThreads();
26082 {
26083 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26084 result = (wxDateSpan *) &_result_ref;
26085 }
26086
26087 wxPyEndAllowThreads(__tstate);
26088 if (PyErr_Occurred()) SWIG_fail;
26089 }
26090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26091 return resultobj;
26092 fail:
26093 return NULL;
26094 }
26095
26096
26097 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26098 PyObject *resultobj;
26099 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26100 wxDateSpan *result;
26101 PyObject * obj0 = 0 ;
26102 char *kwnames[] = {
26103 (char *) "self", NULL
26104 };
26105
26106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26108 if (SWIG_arg_fail(1)) SWIG_fail;
26109 {
26110 PyThreadState* __tstate = wxPyBeginAllowThreads();
26111 {
26112 wxDateSpan &_result_ref = (arg1)->operator -();
26113 result = (wxDateSpan *) &_result_ref;
26114 }
26115
26116 wxPyEndAllowThreads(__tstate);
26117 if (PyErr_Occurred()) SWIG_fail;
26118 }
26119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26120 return resultobj;
26121 fail:
26122 return NULL;
26123 }
26124
26125
26126 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26127 PyObject *resultobj;
26128 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26129 int arg2 ;
26130 wxDateSpan *result;
26131 PyObject * obj0 = 0 ;
26132 PyObject * obj1 = 0 ;
26133 char *kwnames[] = {
26134 (char *) "self",(char *) "factor", NULL
26135 };
26136
26137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26139 if (SWIG_arg_fail(1)) SWIG_fail;
26140 {
26141 arg2 = (int)(SWIG_As_int(obj1));
26142 if (SWIG_arg_fail(2)) SWIG_fail;
26143 }
26144 {
26145 PyThreadState* __tstate = wxPyBeginAllowThreads();
26146 {
26147 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26148 result = (wxDateSpan *) &_result_ref;
26149 }
26150
26151 wxPyEndAllowThreads(__tstate);
26152 if (PyErr_Occurred()) SWIG_fail;
26153 }
26154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26155 return resultobj;
26156 fail:
26157 return NULL;
26158 }
26159
26160
26161 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26162 PyObject *resultobj;
26163 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26164 wxDateSpan *arg2 = 0 ;
26165 wxDateSpan result;
26166 PyObject * obj0 = 0 ;
26167 PyObject * obj1 = 0 ;
26168 char *kwnames[] = {
26169 (char *) "self",(char *) "other", NULL
26170 };
26171
26172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26174 if (SWIG_arg_fail(1)) SWIG_fail;
26175 {
26176 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26177 if (SWIG_arg_fail(2)) SWIG_fail;
26178 if (arg2 == NULL) {
26179 SWIG_null_ref("wxDateSpan");
26180 }
26181 if (SWIG_arg_fail(2)) SWIG_fail;
26182 }
26183 {
26184 PyThreadState* __tstate = wxPyBeginAllowThreads();
26185 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26186
26187 wxPyEndAllowThreads(__tstate);
26188 if (PyErr_Occurred()) SWIG_fail;
26189 }
26190 {
26191 wxDateSpan * resultptr;
26192 resultptr = new wxDateSpan((wxDateSpan &)(result));
26193 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26194 }
26195 return resultobj;
26196 fail:
26197 return NULL;
26198 }
26199
26200
26201 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26202 PyObject *resultobj;
26203 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26204 wxDateSpan *arg2 = 0 ;
26205 wxDateSpan result;
26206 PyObject * obj0 = 0 ;
26207 PyObject * obj1 = 0 ;
26208 char *kwnames[] = {
26209 (char *) "self",(char *) "other", NULL
26210 };
26211
26212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26214 if (SWIG_arg_fail(1)) SWIG_fail;
26215 {
26216 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26217 if (SWIG_arg_fail(2)) SWIG_fail;
26218 if (arg2 == NULL) {
26219 SWIG_null_ref("wxDateSpan");
26220 }
26221 if (SWIG_arg_fail(2)) SWIG_fail;
26222 }
26223 {
26224 PyThreadState* __tstate = wxPyBeginAllowThreads();
26225 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26226
26227 wxPyEndAllowThreads(__tstate);
26228 if (PyErr_Occurred()) SWIG_fail;
26229 }
26230 {
26231 wxDateSpan * resultptr;
26232 resultptr = new wxDateSpan((wxDateSpan &)(result));
26233 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26234 }
26235 return resultobj;
26236 fail:
26237 return NULL;
26238 }
26239
26240
26241 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26242 PyObject *resultobj;
26243 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26244 int arg2 ;
26245 wxDateSpan result;
26246 PyObject * obj0 = 0 ;
26247 PyObject * obj1 = 0 ;
26248 char *kwnames[] = {
26249 (char *) "self",(char *) "n", NULL
26250 };
26251
26252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26254 if (SWIG_arg_fail(1)) SWIG_fail;
26255 {
26256 arg2 = (int)(SWIG_As_int(obj1));
26257 if (SWIG_arg_fail(2)) SWIG_fail;
26258 }
26259 {
26260 PyThreadState* __tstate = wxPyBeginAllowThreads();
26261 result = wxDateSpan___mul__(arg1,arg2);
26262
26263 wxPyEndAllowThreads(__tstate);
26264 if (PyErr_Occurred()) SWIG_fail;
26265 }
26266 {
26267 wxDateSpan * resultptr;
26268 resultptr = new wxDateSpan((wxDateSpan &)(result));
26269 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26270 }
26271 return resultobj;
26272 fail:
26273 return NULL;
26274 }
26275
26276
26277 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26278 PyObject *resultobj;
26279 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26280 int arg2 ;
26281 wxDateSpan result;
26282 PyObject * obj0 = 0 ;
26283 PyObject * obj1 = 0 ;
26284 char *kwnames[] = {
26285 (char *) "self",(char *) "n", NULL
26286 };
26287
26288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26290 if (SWIG_arg_fail(1)) SWIG_fail;
26291 {
26292 arg2 = (int)(SWIG_As_int(obj1));
26293 if (SWIG_arg_fail(2)) SWIG_fail;
26294 }
26295 {
26296 PyThreadState* __tstate = wxPyBeginAllowThreads();
26297 result = wxDateSpan___rmul__(arg1,arg2);
26298
26299 wxPyEndAllowThreads(__tstate);
26300 if (PyErr_Occurred()) SWIG_fail;
26301 }
26302 {
26303 wxDateSpan * resultptr;
26304 resultptr = new wxDateSpan((wxDateSpan &)(result));
26305 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26306 }
26307 return resultobj;
26308 fail:
26309 return NULL;
26310 }
26311
26312
26313 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26314 PyObject *resultobj;
26315 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26316 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26317 bool result;
26318 PyObject * obj0 = 0 ;
26319 PyObject * obj1 = 0 ;
26320 char *kwnames[] = {
26321 (char *) "self",(char *) "other", NULL
26322 };
26323
26324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26326 if (SWIG_arg_fail(1)) SWIG_fail;
26327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26328 if (SWIG_arg_fail(2)) SWIG_fail;
26329 {
26330 PyThreadState* __tstate = wxPyBeginAllowThreads();
26331 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26332
26333 wxPyEndAllowThreads(__tstate);
26334 if (PyErr_Occurred()) SWIG_fail;
26335 }
26336 {
26337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26338 }
26339 return resultobj;
26340 fail:
26341 return NULL;
26342 }
26343
26344
26345 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26346 PyObject *resultobj;
26347 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26348 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26349 bool result;
26350 PyObject * obj0 = 0 ;
26351 PyObject * obj1 = 0 ;
26352 char *kwnames[] = {
26353 (char *) "self",(char *) "other", NULL
26354 };
26355
26356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26358 if (SWIG_arg_fail(1)) SWIG_fail;
26359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26360 if (SWIG_arg_fail(2)) SWIG_fail;
26361 {
26362 PyThreadState* __tstate = wxPyBeginAllowThreads();
26363 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26364
26365 wxPyEndAllowThreads(__tstate);
26366 if (PyErr_Occurred()) SWIG_fail;
26367 }
26368 {
26369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26370 }
26371 return resultobj;
26372 fail:
26373 return NULL;
26374 }
26375
26376
26377 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26378 PyObject *obj;
26379 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26380 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26381 Py_INCREF(obj);
26382 return Py_BuildValue((char *)"");
26383 }
26384 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26385 PyObject *resultobj;
26386 long result;
26387 char *kwnames[] = {
26388 NULL
26389 };
26390
26391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26392 {
26393 PyThreadState* __tstate = wxPyBeginAllowThreads();
26394 result = (long)wxGetLocalTime();
26395
26396 wxPyEndAllowThreads(__tstate);
26397 if (PyErr_Occurred()) SWIG_fail;
26398 }
26399 {
26400 resultobj = SWIG_From_long((long)(result));
26401 }
26402 return resultobj;
26403 fail:
26404 return NULL;
26405 }
26406
26407
26408 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26409 PyObject *resultobj;
26410 long result;
26411 char *kwnames[] = {
26412 NULL
26413 };
26414
26415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26416 {
26417 PyThreadState* __tstate = wxPyBeginAllowThreads();
26418 result = (long)wxGetUTCTime();
26419
26420 wxPyEndAllowThreads(__tstate);
26421 if (PyErr_Occurred()) SWIG_fail;
26422 }
26423 {
26424 resultobj = SWIG_From_long((long)(result));
26425 }
26426 return resultobj;
26427 fail:
26428 return NULL;
26429 }
26430
26431
26432 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26433 PyObject *resultobj;
26434 long result;
26435 char *kwnames[] = {
26436 NULL
26437 };
26438
26439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26440 {
26441 PyThreadState* __tstate = wxPyBeginAllowThreads();
26442 result = (long)wxGetCurrentTime();
26443
26444 wxPyEndAllowThreads(__tstate);
26445 if (PyErr_Occurred()) SWIG_fail;
26446 }
26447 {
26448 resultobj = SWIG_From_long((long)(result));
26449 }
26450 return resultobj;
26451 fail:
26452 return NULL;
26453 }
26454
26455
26456 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26457 PyObject *resultobj;
26458 wxLongLong result;
26459 char *kwnames[] = {
26460 NULL
26461 };
26462
26463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26464 {
26465 PyThreadState* __tstate = wxPyBeginAllowThreads();
26466 result = wxGetLocalTimeMillis();
26467
26468 wxPyEndAllowThreads(__tstate);
26469 if (PyErr_Occurred()) SWIG_fail;
26470 }
26471 {
26472 PyObject *hi, *lo, *shifter, *shifted;
26473 hi = PyLong_FromLong( (&result)->GetHi() );
26474 lo = PyLong_FromLong( (&result)->GetLo() );
26475 shifter = PyLong_FromLong(32);
26476 shifted = PyNumber_Lshift(hi, shifter);
26477 resultobj = PyNumber_Or(shifted, lo);
26478 Py_DECREF(hi);
26479 Py_DECREF(lo);
26480 Py_DECREF(shifter);
26481 Py_DECREF(shifted);
26482 }
26483 return resultobj;
26484 fail:
26485 return NULL;
26486 }
26487
26488
26489 static int _wrap_DefaultDateTime_set(PyObject *) {
26490 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26491 return 1;
26492 }
26493
26494
26495 static PyObject *_wrap_DefaultDateTime_get(void) {
26496 PyObject *pyobj;
26497
26498 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26499 return pyobj;
26500 }
26501
26502
26503 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26504 PyObject *resultobj;
26505 wxDataFormatId arg1 ;
26506 wxDataFormat *result;
26507 PyObject * obj0 = 0 ;
26508 char *kwnames[] = {
26509 (char *) "type", NULL
26510 };
26511
26512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26513 {
26514 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26515 if (SWIG_arg_fail(1)) SWIG_fail;
26516 }
26517 {
26518 PyThreadState* __tstate = wxPyBeginAllowThreads();
26519 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26520
26521 wxPyEndAllowThreads(__tstate);
26522 if (PyErr_Occurred()) SWIG_fail;
26523 }
26524 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26525 return resultobj;
26526 fail:
26527 return NULL;
26528 }
26529
26530
26531 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26532 PyObject *resultobj;
26533 wxString *arg1 = 0 ;
26534 wxDataFormat *result;
26535 bool temp1 = false ;
26536 PyObject * obj0 = 0 ;
26537 char *kwnames[] = {
26538 (char *) "format", NULL
26539 };
26540
26541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26542 {
26543 arg1 = wxString_in_helper(obj0);
26544 if (arg1 == NULL) SWIG_fail;
26545 temp1 = true;
26546 }
26547 {
26548 PyThreadState* __tstate = wxPyBeginAllowThreads();
26549 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26550
26551 wxPyEndAllowThreads(__tstate);
26552 if (PyErr_Occurred()) SWIG_fail;
26553 }
26554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26555 {
26556 if (temp1)
26557 delete arg1;
26558 }
26559 return resultobj;
26560 fail:
26561 {
26562 if (temp1)
26563 delete arg1;
26564 }
26565 return NULL;
26566 }
26567
26568
26569 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26570 PyObject *resultobj;
26571 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26572 PyObject * obj0 = 0 ;
26573 char *kwnames[] = {
26574 (char *) "self", NULL
26575 };
26576
26577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26579 if (SWIG_arg_fail(1)) SWIG_fail;
26580 {
26581 PyThreadState* __tstate = wxPyBeginAllowThreads();
26582 delete arg1;
26583
26584 wxPyEndAllowThreads(__tstate);
26585 if (PyErr_Occurred()) SWIG_fail;
26586 }
26587 Py_INCREF(Py_None); resultobj = Py_None;
26588 return resultobj;
26589 fail:
26590 return NULL;
26591 }
26592
26593
26594 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26595 PyObject *resultobj;
26596 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26597 wxDataFormatId arg2 ;
26598 bool result;
26599 PyObject * obj0 = 0 ;
26600 PyObject * obj1 = 0 ;
26601
26602 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26604 if (SWIG_arg_fail(1)) SWIG_fail;
26605 {
26606 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26607 if (SWIG_arg_fail(2)) SWIG_fail;
26608 }
26609 {
26610 PyThreadState* __tstate = wxPyBeginAllowThreads();
26611 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26612
26613 wxPyEndAllowThreads(__tstate);
26614 if (PyErr_Occurred()) SWIG_fail;
26615 }
26616 {
26617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26618 }
26619 return resultobj;
26620 fail:
26621 return NULL;
26622 }
26623
26624
26625 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26626 PyObject *resultobj;
26627 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26628 wxDataFormatId arg2 ;
26629 bool result;
26630 PyObject * obj0 = 0 ;
26631 PyObject * obj1 = 0 ;
26632
26633 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26635 if (SWIG_arg_fail(1)) SWIG_fail;
26636 {
26637 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26638 if (SWIG_arg_fail(2)) SWIG_fail;
26639 }
26640 {
26641 PyThreadState* __tstate = wxPyBeginAllowThreads();
26642 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26643
26644 wxPyEndAllowThreads(__tstate);
26645 if (PyErr_Occurred()) SWIG_fail;
26646 }
26647 {
26648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26649 }
26650 return resultobj;
26651 fail:
26652 return NULL;
26653 }
26654
26655
26656 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26657 PyObject *resultobj;
26658 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26659 wxDataFormat *arg2 = 0 ;
26660 bool result;
26661 PyObject * obj0 = 0 ;
26662 PyObject * obj1 = 0 ;
26663
26664 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26666 if (SWIG_arg_fail(1)) SWIG_fail;
26667 {
26668 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26669 if (SWIG_arg_fail(2)) SWIG_fail;
26670 if (arg2 == NULL) {
26671 SWIG_null_ref("wxDataFormat");
26672 }
26673 if (SWIG_arg_fail(2)) SWIG_fail;
26674 }
26675 {
26676 PyThreadState* __tstate = wxPyBeginAllowThreads();
26677 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26678
26679 wxPyEndAllowThreads(__tstate);
26680 if (PyErr_Occurred()) SWIG_fail;
26681 }
26682 {
26683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26684 }
26685 return resultobj;
26686 fail:
26687 return NULL;
26688 }
26689
26690
26691 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26692 int argc;
26693 PyObject *argv[3];
26694 int ii;
26695
26696 argc = PyObject_Length(args);
26697 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26698 argv[ii] = PyTuple_GetItem(args,ii);
26699 }
26700 if (argc == 2) {
26701 int _v;
26702 {
26703 void *ptr;
26704 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26705 _v = 0;
26706 PyErr_Clear();
26707 } else {
26708 _v = 1;
26709 }
26710 }
26711 if (_v) {
26712 {
26713 void *ptr = 0;
26714 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26715 _v = 0;
26716 PyErr_Clear();
26717 } else {
26718 _v = (ptr != 0);
26719 }
26720 }
26721 if (_v) {
26722 return _wrap_DataFormat___eq____SWIG_1(self,args);
26723 }
26724 }
26725 }
26726 if (argc == 2) {
26727 int _v;
26728 {
26729 void *ptr;
26730 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26731 _v = 0;
26732 PyErr_Clear();
26733 } else {
26734 _v = 1;
26735 }
26736 }
26737 if (_v) {
26738 _v = SWIG_Check_int(argv[1]);
26739 if (_v) {
26740 return _wrap_DataFormat___eq____SWIG_0(self,args);
26741 }
26742 }
26743 }
26744
26745 Py_INCREF(Py_NotImplemented);
26746 return Py_NotImplemented;
26747 }
26748
26749
26750 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26751 PyObject *resultobj;
26752 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26753 wxDataFormat *arg2 = 0 ;
26754 bool result;
26755 PyObject * obj0 = 0 ;
26756 PyObject * obj1 = 0 ;
26757
26758 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26760 if (SWIG_arg_fail(1)) SWIG_fail;
26761 {
26762 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26763 if (SWIG_arg_fail(2)) SWIG_fail;
26764 if (arg2 == NULL) {
26765 SWIG_null_ref("wxDataFormat");
26766 }
26767 if (SWIG_arg_fail(2)) SWIG_fail;
26768 }
26769 {
26770 PyThreadState* __tstate = wxPyBeginAllowThreads();
26771 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26772
26773 wxPyEndAllowThreads(__tstate);
26774 if (PyErr_Occurred()) SWIG_fail;
26775 }
26776 {
26777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26778 }
26779 return resultobj;
26780 fail:
26781 return NULL;
26782 }
26783
26784
26785 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26786 int argc;
26787 PyObject *argv[3];
26788 int ii;
26789
26790 argc = PyObject_Length(args);
26791 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26792 argv[ii] = PyTuple_GetItem(args,ii);
26793 }
26794 if (argc == 2) {
26795 int _v;
26796 {
26797 void *ptr;
26798 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26799 _v = 0;
26800 PyErr_Clear();
26801 } else {
26802 _v = 1;
26803 }
26804 }
26805 if (_v) {
26806 {
26807 void *ptr = 0;
26808 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26809 _v = 0;
26810 PyErr_Clear();
26811 } else {
26812 _v = (ptr != 0);
26813 }
26814 }
26815 if (_v) {
26816 return _wrap_DataFormat___ne____SWIG_1(self,args);
26817 }
26818 }
26819 }
26820 if (argc == 2) {
26821 int _v;
26822 {
26823 void *ptr;
26824 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26825 _v = 0;
26826 PyErr_Clear();
26827 } else {
26828 _v = 1;
26829 }
26830 }
26831 if (_v) {
26832 _v = SWIG_Check_int(argv[1]);
26833 if (_v) {
26834 return _wrap_DataFormat___ne____SWIG_0(self,args);
26835 }
26836 }
26837 }
26838
26839 Py_INCREF(Py_NotImplemented);
26840 return Py_NotImplemented;
26841 }
26842
26843
26844 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26845 PyObject *resultobj;
26846 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26847 wxDataFormatId arg2 ;
26848 PyObject * obj0 = 0 ;
26849 PyObject * obj1 = 0 ;
26850 char *kwnames[] = {
26851 (char *) "self",(char *) "format", NULL
26852 };
26853
26854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26856 if (SWIG_arg_fail(1)) SWIG_fail;
26857 {
26858 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26859 if (SWIG_arg_fail(2)) SWIG_fail;
26860 }
26861 {
26862 PyThreadState* __tstate = wxPyBeginAllowThreads();
26863 (arg1)->SetType((wxDataFormatId )arg2);
26864
26865 wxPyEndAllowThreads(__tstate);
26866 if (PyErr_Occurred()) SWIG_fail;
26867 }
26868 Py_INCREF(Py_None); resultobj = Py_None;
26869 return resultobj;
26870 fail:
26871 return NULL;
26872 }
26873
26874
26875 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26876 PyObject *resultobj;
26877 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26878 wxDataFormatId result;
26879 PyObject * obj0 = 0 ;
26880 char *kwnames[] = {
26881 (char *) "self", NULL
26882 };
26883
26884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26886 if (SWIG_arg_fail(1)) SWIG_fail;
26887 {
26888 PyThreadState* __tstate = wxPyBeginAllowThreads();
26889 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26890
26891 wxPyEndAllowThreads(__tstate);
26892 if (PyErr_Occurred()) SWIG_fail;
26893 }
26894 resultobj = SWIG_From_int((result));
26895 return resultobj;
26896 fail:
26897 return NULL;
26898 }
26899
26900
26901 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26902 PyObject *resultobj;
26903 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26904 wxString result;
26905 PyObject * obj0 = 0 ;
26906 char *kwnames[] = {
26907 (char *) "self", NULL
26908 };
26909
26910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26912 if (SWIG_arg_fail(1)) SWIG_fail;
26913 {
26914 PyThreadState* __tstate = wxPyBeginAllowThreads();
26915 result = ((wxDataFormat const *)arg1)->GetId();
26916
26917 wxPyEndAllowThreads(__tstate);
26918 if (PyErr_Occurred()) SWIG_fail;
26919 }
26920 {
26921 #if wxUSE_UNICODE
26922 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26923 #else
26924 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26925 #endif
26926 }
26927 return resultobj;
26928 fail:
26929 return NULL;
26930 }
26931
26932
26933 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26934 PyObject *resultobj;
26935 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26936 wxString *arg2 = 0 ;
26937 bool temp2 = false ;
26938 PyObject * obj0 = 0 ;
26939 PyObject * obj1 = 0 ;
26940 char *kwnames[] = {
26941 (char *) "self",(char *) "format", NULL
26942 };
26943
26944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26946 if (SWIG_arg_fail(1)) SWIG_fail;
26947 {
26948 arg2 = wxString_in_helper(obj1);
26949 if (arg2 == NULL) SWIG_fail;
26950 temp2 = true;
26951 }
26952 {
26953 PyThreadState* __tstate = wxPyBeginAllowThreads();
26954 (arg1)->SetId((wxString const &)*arg2);
26955
26956 wxPyEndAllowThreads(__tstate);
26957 if (PyErr_Occurred()) SWIG_fail;
26958 }
26959 Py_INCREF(Py_None); resultobj = Py_None;
26960 {
26961 if (temp2)
26962 delete arg2;
26963 }
26964 return resultobj;
26965 fail:
26966 {
26967 if (temp2)
26968 delete arg2;
26969 }
26970 return NULL;
26971 }
26972
26973
26974 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26975 PyObject *obj;
26976 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26977 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26978 Py_INCREF(obj);
26979 return Py_BuildValue((char *)"");
26980 }
26981 static int _wrap_FormatInvalid_set(PyObject *) {
26982 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26983 return 1;
26984 }
26985
26986
26987 static PyObject *_wrap_FormatInvalid_get(void) {
26988 PyObject *pyobj;
26989
26990 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26991 return pyobj;
26992 }
26993
26994
26995 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26996 PyObject *resultobj;
26997 wxDataObject *arg1 = (wxDataObject *) 0 ;
26998 PyObject * obj0 = 0 ;
26999 char *kwnames[] = {
27000 (char *) "self", NULL
27001 };
27002
27003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27005 if (SWIG_arg_fail(1)) SWIG_fail;
27006 {
27007 PyThreadState* __tstate = wxPyBeginAllowThreads();
27008 delete arg1;
27009
27010 wxPyEndAllowThreads(__tstate);
27011 if (PyErr_Occurred()) SWIG_fail;
27012 }
27013 Py_INCREF(Py_None); resultobj = Py_None;
27014 return resultobj;
27015 fail:
27016 return NULL;
27017 }
27018
27019
27020 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27021 PyObject *resultobj;
27022 wxDataObject *arg1 = (wxDataObject *) 0 ;
27023 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27024 SwigValueWrapper<wxDataFormat > result;
27025 PyObject * obj0 = 0 ;
27026 PyObject * obj1 = 0 ;
27027 char *kwnames[] = {
27028 (char *) "self",(char *) "dir", NULL
27029 };
27030
27031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27033 if (SWIG_arg_fail(1)) SWIG_fail;
27034 if (obj1) {
27035 {
27036 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27037 if (SWIG_arg_fail(2)) SWIG_fail;
27038 }
27039 }
27040 {
27041 PyThreadState* __tstate = wxPyBeginAllowThreads();
27042 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27043
27044 wxPyEndAllowThreads(__tstate);
27045 if (PyErr_Occurred()) SWIG_fail;
27046 }
27047 {
27048 wxDataFormat * resultptr;
27049 resultptr = new wxDataFormat((wxDataFormat &)(result));
27050 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27051 }
27052 return resultobj;
27053 fail:
27054 return NULL;
27055 }
27056
27057
27058 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27059 PyObject *resultobj;
27060 wxDataObject *arg1 = (wxDataObject *) 0 ;
27061 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27062 size_t result;
27063 PyObject * obj0 = 0 ;
27064 PyObject * obj1 = 0 ;
27065 char *kwnames[] = {
27066 (char *) "self",(char *) "dir", NULL
27067 };
27068
27069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27071 if (SWIG_arg_fail(1)) SWIG_fail;
27072 if (obj1) {
27073 {
27074 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27075 if (SWIG_arg_fail(2)) SWIG_fail;
27076 }
27077 }
27078 {
27079 PyThreadState* __tstate = wxPyBeginAllowThreads();
27080 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27081
27082 wxPyEndAllowThreads(__tstate);
27083 if (PyErr_Occurred()) SWIG_fail;
27084 }
27085 {
27086 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27087 }
27088 return resultobj;
27089 fail:
27090 return NULL;
27091 }
27092
27093
27094 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27095 PyObject *resultobj;
27096 wxDataObject *arg1 = (wxDataObject *) 0 ;
27097 wxDataFormat *arg2 = 0 ;
27098 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27099 bool result;
27100 PyObject * obj0 = 0 ;
27101 PyObject * obj1 = 0 ;
27102 PyObject * obj2 = 0 ;
27103 char *kwnames[] = {
27104 (char *) "self",(char *) "format",(char *) "dir", NULL
27105 };
27106
27107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27109 if (SWIG_arg_fail(1)) SWIG_fail;
27110 {
27111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27112 if (SWIG_arg_fail(2)) SWIG_fail;
27113 if (arg2 == NULL) {
27114 SWIG_null_ref("wxDataFormat");
27115 }
27116 if (SWIG_arg_fail(2)) SWIG_fail;
27117 }
27118 if (obj2) {
27119 {
27120 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27121 if (SWIG_arg_fail(3)) SWIG_fail;
27122 }
27123 }
27124 {
27125 PyThreadState* __tstate = wxPyBeginAllowThreads();
27126 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27127
27128 wxPyEndAllowThreads(__tstate);
27129 if (PyErr_Occurred()) SWIG_fail;
27130 }
27131 {
27132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27133 }
27134 return resultobj;
27135 fail:
27136 return NULL;
27137 }
27138
27139
27140 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27141 PyObject *resultobj;
27142 wxDataObject *arg1 = (wxDataObject *) 0 ;
27143 wxDataFormat *arg2 = 0 ;
27144 size_t result;
27145 PyObject * obj0 = 0 ;
27146 PyObject * obj1 = 0 ;
27147 char *kwnames[] = {
27148 (char *) "self",(char *) "format", NULL
27149 };
27150
27151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27153 if (SWIG_arg_fail(1)) SWIG_fail;
27154 {
27155 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27156 if (SWIG_arg_fail(2)) SWIG_fail;
27157 if (arg2 == NULL) {
27158 SWIG_null_ref("wxDataFormat");
27159 }
27160 if (SWIG_arg_fail(2)) SWIG_fail;
27161 }
27162 {
27163 PyThreadState* __tstate = wxPyBeginAllowThreads();
27164 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27165
27166 wxPyEndAllowThreads(__tstate);
27167 if (PyErr_Occurred()) SWIG_fail;
27168 }
27169 {
27170 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27171 }
27172 return resultobj;
27173 fail:
27174 return NULL;
27175 }
27176
27177
27178 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27179 PyObject *resultobj;
27180 wxDataObject *arg1 = (wxDataObject *) 0 ;
27181 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27182 PyObject *result;
27183 PyObject * obj0 = 0 ;
27184 PyObject * obj1 = 0 ;
27185 char *kwnames[] = {
27186 (char *) "self",(char *) "dir", NULL
27187 };
27188
27189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27191 if (SWIG_arg_fail(1)) SWIG_fail;
27192 if (obj1) {
27193 {
27194 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27195 if (SWIG_arg_fail(2)) SWIG_fail;
27196 }
27197 }
27198 {
27199 PyThreadState* __tstate = wxPyBeginAllowThreads();
27200 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27201
27202 wxPyEndAllowThreads(__tstate);
27203 if (PyErr_Occurred()) SWIG_fail;
27204 }
27205 resultobj = result;
27206 return resultobj;
27207 fail:
27208 return NULL;
27209 }
27210
27211
27212 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27213 PyObject *resultobj;
27214 wxDataObject *arg1 = (wxDataObject *) 0 ;
27215 wxDataFormat *arg2 = 0 ;
27216 PyObject *result;
27217 PyObject * obj0 = 0 ;
27218 PyObject * obj1 = 0 ;
27219 char *kwnames[] = {
27220 (char *) "self",(char *) "format", NULL
27221 };
27222
27223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27225 if (SWIG_arg_fail(1)) SWIG_fail;
27226 {
27227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27228 if (SWIG_arg_fail(2)) SWIG_fail;
27229 if (arg2 == NULL) {
27230 SWIG_null_ref("wxDataFormat");
27231 }
27232 if (SWIG_arg_fail(2)) SWIG_fail;
27233 }
27234 {
27235 PyThreadState* __tstate = wxPyBeginAllowThreads();
27236 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27237
27238 wxPyEndAllowThreads(__tstate);
27239 if (PyErr_Occurred()) SWIG_fail;
27240 }
27241 resultobj = result;
27242 return resultobj;
27243 fail:
27244 return NULL;
27245 }
27246
27247
27248 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27249 PyObject *resultobj;
27250 wxDataObject *arg1 = (wxDataObject *) 0 ;
27251 wxDataFormat *arg2 = 0 ;
27252 PyObject *arg3 = (PyObject *) 0 ;
27253 bool result;
27254 PyObject * obj0 = 0 ;
27255 PyObject * obj1 = 0 ;
27256 PyObject * obj2 = 0 ;
27257 char *kwnames[] = {
27258 (char *) "self",(char *) "format",(char *) "data", NULL
27259 };
27260
27261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27263 if (SWIG_arg_fail(1)) SWIG_fail;
27264 {
27265 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27266 if (SWIG_arg_fail(2)) SWIG_fail;
27267 if (arg2 == NULL) {
27268 SWIG_null_ref("wxDataFormat");
27269 }
27270 if (SWIG_arg_fail(2)) SWIG_fail;
27271 }
27272 arg3 = obj2;
27273 {
27274 PyThreadState* __tstate = wxPyBeginAllowThreads();
27275 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27276
27277 wxPyEndAllowThreads(__tstate);
27278 if (PyErr_Occurred()) SWIG_fail;
27279 }
27280 {
27281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27282 }
27283 return resultobj;
27284 fail:
27285 return NULL;
27286 }
27287
27288
27289 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27290 PyObject *obj;
27291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27292 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27293 Py_INCREF(obj);
27294 return Py_BuildValue((char *)"");
27295 }
27296 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27297 PyObject *resultobj;
27298 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27299 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27300 wxDataObjectSimple *result;
27301 PyObject * obj0 = 0 ;
27302 char *kwnames[] = {
27303 (char *) "format", NULL
27304 };
27305
27306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27307 if (obj0) {
27308 {
27309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27310 if (SWIG_arg_fail(1)) SWIG_fail;
27311 if (arg1 == NULL) {
27312 SWIG_null_ref("wxDataFormat");
27313 }
27314 if (SWIG_arg_fail(1)) SWIG_fail;
27315 }
27316 }
27317 {
27318 PyThreadState* __tstate = wxPyBeginAllowThreads();
27319 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27320
27321 wxPyEndAllowThreads(__tstate);
27322 if (PyErr_Occurred()) SWIG_fail;
27323 }
27324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27325 return resultobj;
27326 fail:
27327 return NULL;
27328 }
27329
27330
27331 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27332 PyObject *resultobj;
27333 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27334 wxDataFormat *result;
27335 PyObject * obj0 = 0 ;
27336 char *kwnames[] = {
27337 (char *) "self", NULL
27338 };
27339
27340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27342 if (SWIG_arg_fail(1)) SWIG_fail;
27343 {
27344 PyThreadState* __tstate = wxPyBeginAllowThreads();
27345 {
27346 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27347 result = (wxDataFormat *) &_result_ref;
27348 }
27349
27350 wxPyEndAllowThreads(__tstate);
27351 if (PyErr_Occurred()) SWIG_fail;
27352 }
27353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27354 return resultobj;
27355 fail:
27356 return NULL;
27357 }
27358
27359
27360 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27361 PyObject *resultobj;
27362 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27363 wxDataFormat *arg2 = 0 ;
27364 PyObject * obj0 = 0 ;
27365 PyObject * obj1 = 0 ;
27366 char *kwnames[] = {
27367 (char *) "self",(char *) "format", NULL
27368 };
27369
27370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27372 if (SWIG_arg_fail(1)) SWIG_fail;
27373 {
27374 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27375 if (SWIG_arg_fail(2)) SWIG_fail;
27376 if (arg2 == NULL) {
27377 SWIG_null_ref("wxDataFormat");
27378 }
27379 if (SWIG_arg_fail(2)) SWIG_fail;
27380 }
27381 {
27382 PyThreadState* __tstate = wxPyBeginAllowThreads();
27383 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27384
27385 wxPyEndAllowThreads(__tstate);
27386 if (PyErr_Occurred()) SWIG_fail;
27387 }
27388 Py_INCREF(Py_None); resultobj = Py_None;
27389 return resultobj;
27390 fail:
27391 return NULL;
27392 }
27393
27394
27395 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27396 PyObject *resultobj;
27397 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27398 size_t result;
27399 PyObject * obj0 = 0 ;
27400 char *kwnames[] = {
27401 (char *) "self", NULL
27402 };
27403
27404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27406 if (SWIG_arg_fail(1)) SWIG_fail;
27407 {
27408 PyThreadState* __tstate = wxPyBeginAllowThreads();
27409 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27410
27411 wxPyEndAllowThreads(__tstate);
27412 if (PyErr_Occurred()) SWIG_fail;
27413 }
27414 {
27415 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27416 }
27417 return resultobj;
27418 fail:
27419 return NULL;
27420 }
27421
27422
27423 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27424 PyObject *resultobj;
27425 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27426 PyObject *result;
27427 PyObject * obj0 = 0 ;
27428 char *kwnames[] = {
27429 (char *) "self", NULL
27430 };
27431
27432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27434 if (SWIG_arg_fail(1)) SWIG_fail;
27435 {
27436 PyThreadState* __tstate = wxPyBeginAllowThreads();
27437 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27438
27439 wxPyEndAllowThreads(__tstate);
27440 if (PyErr_Occurred()) SWIG_fail;
27441 }
27442 resultobj = result;
27443 return resultobj;
27444 fail:
27445 return NULL;
27446 }
27447
27448
27449 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27450 PyObject *resultobj;
27451 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27452 PyObject *arg2 = (PyObject *) 0 ;
27453 bool result;
27454 PyObject * obj0 = 0 ;
27455 PyObject * obj1 = 0 ;
27456 char *kwnames[] = {
27457 (char *) "self",(char *) "data", NULL
27458 };
27459
27460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27462 if (SWIG_arg_fail(1)) SWIG_fail;
27463 arg2 = obj1;
27464 {
27465 PyThreadState* __tstate = wxPyBeginAllowThreads();
27466 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27467
27468 wxPyEndAllowThreads(__tstate);
27469 if (PyErr_Occurred()) SWIG_fail;
27470 }
27471 {
27472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27473 }
27474 return resultobj;
27475 fail:
27476 return NULL;
27477 }
27478
27479
27480 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27481 PyObject *obj;
27482 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27483 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27484 Py_INCREF(obj);
27485 return Py_BuildValue((char *)"");
27486 }
27487 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27488 PyObject *resultobj;
27489 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27490 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27491 wxPyDataObjectSimple *result;
27492 PyObject * obj0 = 0 ;
27493 char *kwnames[] = {
27494 (char *) "format", NULL
27495 };
27496
27497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27498 if (obj0) {
27499 {
27500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27501 if (SWIG_arg_fail(1)) SWIG_fail;
27502 if (arg1 == NULL) {
27503 SWIG_null_ref("wxDataFormat");
27504 }
27505 if (SWIG_arg_fail(1)) SWIG_fail;
27506 }
27507 }
27508 {
27509 PyThreadState* __tstate = wxPyBeginAllowThreads();
27510 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27511
27512 wxPyEndAllowThreads(__tstate);
27513 if (PyErr_Occurred()) SWIG_fail;
27514 }
27515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27516 return resultobj;
27517 fail:
27518 return NULL;
27519 }
27520
27521
27522 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27523 PyObject *resultobj;
27524 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27525 PyObject *arg2 = (PyObject *) 0 ;
27526 PyObject *arg3 = (PyObject *) 0 ;
27527 PyObject * obj0 = 0 ;
27528 PyObject * obj1 = 0 ;
27529 PyObject * obj2 = 0 ;
27530 char *kwnames[] = {
27531 (char *) "self",(char *) "self",(char *) "_class", NULL
27532 };
27533
27534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27536 if (SWIG_arg_fail(1)) SWIG_fail;
27537 arg2 = obj1;
27538 arg3 = obj2;
27539 {
27540 PyThreadState* __tstate = wxPyBeginAllowThreads();
27541 (arg1)->_setCallbackInfo(arg2,arg3);
27542
27543 wxPyEndAllowThreads(__tstate);
27544 if (PyErr_Occurred()) SWIG_fail;
27545 }
27546 Py_INCREF(Py_None); resultobj = Py_None;
27547 return resultobj;
27548 fail:
27549 return NULL;
27550 }
27551
27552
27553 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27554 PyObject *obj;
27555 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27556 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27557 Py_INCREF(obj);
27558 return Py_BuildValue((char *)"");
27559 }
27560 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27561 PyObject *resultobj;
27562 wxDataObjectComposite *result;
27563 char *kwnames[] = {
27564 NULL
27565 };
27566
27567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27568 {
27569 PyThreadState* __tstate = wxPyBeginAllowThreads();
27570 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27571
27572 wxPyEndAllowThreads(__tstate);
27573 if (PyErr_Occurred()) SWIG_fail;
27574 }
27575 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27576 return resultobj;
27577 fail:
27578 return NULL;
27579 }
27580
27581
27582 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27583 PyObject *resultobj;
27584 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27585 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27586 bool arg3 = (bool) false ;
27587 PyObject * obj0 = 0 ;
27588 PyObject * obj1 = 0 ;
27589 PyObject * obj2 = 0 ;
27590 char *kwnames[] = {
27591 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27592 };
27593
27594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27596 if (SWIG_arg_fail(1)) SWIG_fail;
27597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27598 if (SWIG_arg_fail(2)) SWIG_fail;
27599 if (obj2) {
27600 {
27601 arg3 = (bool)(SWIG_As_bool(obj2));
27602 if (SWIG_arg_fail(3)) SWIG_fail;
27603 }
27604 }
27605 {
27606 PyThreadState* __tstate = wxPyBeginAllowThreads();
27607 (arg1)->Add(arg2,arg3);
27608
27609 wxPyEndAllowThreads(__tstate);
27610 if (PyErr_Occurred()) SWIG_fail;
27611 }
27612 Py_INCREF(Py_None); resultobj = Py_None;
27613 return resultobj;
27614 fail:
27615 return NULL;
27616 }
27617
27618
27619 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27620 PyObject *obj;
27621 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27622 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27623 Py_INCREF(obj);
27624 return Py_BuildValue((char *)"");
27625 }
27626 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27627 PyObject *resultobj;
27628 wxString const &arg1_defvalue = wxPyEmptyString ;
27629 wxString *arg1 = (wxString *) &arg1_defvalue ;
27630 wxTextDataObject *result;
27631 bool temp1 = false ;
27632 PyObject * obj0 = 0 ;
27633 char *kwnames[] = {
27634 (char *) "text", NULL
27635 };
27636
27637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27638 if (obj0) {
27639 {
27640 arg1 = wxString_in_helper(obj0);
27641 if (arg1 == NULL) SWIG_fail;
27642 temp1 = true;
27643 }
27644 }
27645 {
27646 PyThreadState* __tstate = wxPyBeginAllowThreads();
27647 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27648
27649 wxPyEndAllowThreads(__tstate);
27650 if (PyErr_Occurred()) SWIG_fail;
27651 }
27652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27653 {
27654 if (temp1)
27655 delete arg1;
27656 }
27657 return resultobj;
27658 fail:
27659 {
27660 if (temp1)
27661 delete arg1;
27662 }
27663 return NULL;
27664 }
27665
27666
27667 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27668 PyObject *resultobj;
27669 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27670 size_t result;
27671 PyObject * obj0 = 0 ;
27672 char *kwnames[] = {
27673 (char *) "self", NULL
27674 };
27675
27676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27678 if (SWIG_arg_fail(1)) SWIG_fail;
27679 {
27680 PyThreadState* __tstate = wxPyBeginAllowThreads();
27681 result = (size_t)(arg1)->GetTextLength();
27682
27683 wxPyEndAllowThreads(__tstate);
27684 if (PyErr_Occurred()) SWIG_fail;
27685 }
27686 {
27687 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27688 }
27689 return resultobj;
27690 fail:
27691 return NULL;
27692 }
27693
27694
27695 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27696 PyObject *resultobj;
27697 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27698 wxString result;
27699 PyObject * obj0 = 0 ;
27700 char *kwnames[] = {
27701 (char *) "self", NULL
27702 };
27703
27704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27706 if (SWIG_arg_fail(1)) SWIG_fail;
27707 {
27708 PyThreadState* __tstate = wxPyBeginAllowThreads();
27709 result = (arg1)->GetText();
27710
27711 wxPyEndAllowThreads(__tstate);
27712 if (PyErr_Occurred()) SWIG_fail;
27713 }
27714 {
27715 #if wxUSE_UNICODE
27716 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27717 #else
27718 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27719 #endif
27720 }
27721 return resultobj;
27722 fail:
27723 return NULL;
27724 }
27725
27726
27727 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27728 PyObject *resultobj;
27729 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27730 wxString *arg2 = 0 ;
27731 bool temp2 = false ;
27732 PyObject * obj0 = 0 ;
27733 PyObject * obj1 = 0 ;
27734 char *kwnames[] = {
27735 (char *) "self",(char *) "text", NULL
27736 };
27737
27738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27740 if (SWIG_arg_fail(1)) SWIG_fail;
27741 {
27742 arg2 = wxString_in_helper(obj1);
27743 if (arg2 == NULL) SWIG_fail;
27744 temp2 = true;
27745 }
27746 {
27747 PyThreadState* __tstate = wxPyBeginAllowThreads();
27748 (arg1)->SetText((wxString const &)*arg2);
27749
27750 wxPyEndAllowThreads(__tstate);
27751 if (PyErr_Occurred()) SWIG_fail;
27752 }
27753 Py_INCREF(Py_None); resultobj = Py_None;
27754 {
27755 if (temp2)
27756 delete arg2;
27757 }
27758 return resultobj;
27759 fail:
27760 {
27761 if (temp2)
27762 delete arg2;
27763 }
27764 return NULL;
27765 }
27766
27767
27768 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27769 PyObject *obj;
27770 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27771 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27772 Py_INCREF(obj);
27773 return Py_BuildValue((char *)"");
27774 }
27775 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27776 PyObject *resultobj;
27777 wxString const &arg1_defvalue = wxPyEmptyString ;
27778 wxString *arg1 = (wxString *) &arg1_defvalue ;
27779 wxPyTextDataObject *result;
27780 bool temp1 = false ;
27781 PyObject * obj0 = 0 ;
27782 char *kwnames[] = {
27783 (char *) "text", NULL
27784 };
27785
27786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27787 if (obj0) {
27788 {
27789 arg1 = wxString_in_helper(obj0);
27790 if (arg1 == NULL) SWIG_fail;
27791 temp1 = true;
27792 }
27793 }
27794 {
27795 PyThreadState* __tstate = wxPyBeginAllowThreads();
27796 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27797
27798 wxPyEndAllowThreads(__tstate);
27799 if (PyErr_Occurred()) SWIG_fail;
27800 }
27801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27802 {
27803 if (temp1)
27804 delete arg1;
27805 }
27806 return resultobj;
27807 fail:
27808 {
27809 if (temp1)
27810 delete arg1;
27811 }
27812 return NULL;
27813 }
27814
27815
27816 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27817 PyObject *resultobj;
27818 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27819 PyObject *arg2 = (PyObject *) 0 ;
27820 PyObject *arg3 = (PyObject *) 0 ;
27821 PyObject * obj0 = 0 ;
27822 PyObject * obj1 = 0 ;
27823 PyObject * obj2 = 0 ;
27824 char *kwnames[] = {
27825 (char *) "self",(char *) "self",(char *) "_class", NULL
27826 };
27827
27828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27830 if (SWIG_arg_fail(1)) SWIG_fail;
27831 arg2 = obj1;
27832 arg3 = obj2;
27833 {
27834 PyThreadState* __tstate = wxPyBeginAllowThreads();
27835 (arg1)->_setCallbackInfo(arg2,arg3);
27836
27837 wxPyEndAllowThreads(__tstate);
27838 if (PyErr_Occurred()) SWIG_fail;
27839 }
27840 Py_INCREF(Py_None); resultobj = Py_None;
27841 return resultobj;
27842 fail:
27843 return NULL;
27844 }
27845
27846
27847 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27848 PyObject *obj;
27849 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27850 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27851 Py_INCREF(obj);
27852 return Py_BuildValue((char *)"");
27853 }
27854 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27855 PyObject *resultobj;
27856 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27857 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27858 wxBitmapDataObject *result;
27859 PyObject * obj0 = 0 ;
27860 char *kwnames[] = {
27861 (char *) "bitmap", NULL
27862 };
27863
27864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27865 if (obj0) {
27866 {
27867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27868 if (SWIG_arg_fail(1)) SWIG_fail;
27869 if (arg1 == NULL) {
27870 SWIG_null_ref("wxBitmap");
27871 }
27872 if (SWIG_arg_fail(1)) SWIG_fail;
27873 }
27874 }
27875 {
27876 PyThreadState* __tstate = wxPyBeginAllowThreads();
27877 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27878
27879 wxPyEndAllowThreads(__tstate);
27880 if (PyErr_Occurred()) SWIG_fail;
27881 }
27882 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27883 return resultobj;
27884 fail:
27885 return NULL;
27886 }
27887
27888
27889 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27890 PyObject *resultobj;
27891 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27892 wxBitmap result;
27893 PyObject * obj0 = 0 ;
27894 char *kwnames[] = {
27895 (char *) "self", NULL
27896 };
27897
27898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27900 if (SWIG_arg_fail(1)) SWIG_fail;
27901 {
27902 PyThreadState* __tstate = wxPyBeginAllowThreads();
27903 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27904
27905 wxPyEndAllowThreads(__tstate);
27906 if (PyErr_Occurred()) SWIG_fail;
27907 }
27908 {
27909 wxBitmap * resultptr;
27910 resultptr = new wxBitmap((wxBitmap &)(result));
27911 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27912 }
27913 return resultobj;
27914 fail:
27915 return NULL;
27916 }
27917
27918
27919 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27920 PyObject *resultobj;
27921 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27922 wxBitmap *arg2 = 0 ;
27923 PyObject * obj0 = 0 ;
27924 PyObject * obj1 = 0 ;
27925 char *kwnames[] = {
27926 (char *) "self",(char *) "bitmap", NULL
27927 };
27928
27929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27931 if (SWIG_arg_fail(1)) SWIG_fail;
27932 {
27933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27934 if (SWIG_arg_fail(2)) SWIG_fail;
27935 if (arg2 == NULL) {
27936 SWIG_null_ref("wxBitmap");
27937 }
27938 if (SWIG_arg_fail(2)) SWIG_fail;
27939 }
27940 {
27941 PyThreadState* __tstate = wxPyBeginAllowThreads();
27942 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27943
27944 wxPyEndAllowThreads(__tstate);
27945 if (PyErr_Occurred()) SWIG_fail;
27946 }
27947 Py_INCREF(Py_None); resultobj = Py_None;
27948 return resultobj;
27949 fail:
27950 return NULL;
27951 }
27952
27953
27954 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27955 PyObject *obj;
27956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27957 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27958 Py_INCREF(obj);
27959 return Py_BuildValue((char *)"");
27960 }
27961 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27962 PyObject *resultobj;
27963 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27964 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27965 wxPyBitmapDataObject *result;
27966 PyObject * obj0 = 0 ;
27967 char *kwnames[] = {
27968 (char *) "bitmap", NULL
27969 };
27970
27971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27972 if (obj0) {
27973 {
27974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27975 if (SWIG_arg_fail(1)) SWIG_fail;
27976 if (arg1 == NULL) {
27977 SWIG_null_ref("wxBitmap");
27978 }
27979 if (SWIG_arg_fail(1)) SWIG_fail;
27980 }
27981 }
27982 {
27983 PyThreadState* __tstate = wxPyBeginAllowThreads();
27984 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27985
27986 wxPyEndAllowThreads(__tstate);
27987 if (PyErr_Occurred()) SWIG_fail;
27988 }
27989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27990 return resultobj;
27991 fail:
27992 return NULL;
27993 }
27994
27995
27996 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27997 PyObject *resultobj;
27998 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27999 PyObject *arg2 = (PyObject *) 0 ;
28000 PyObject *arg3 = (PyObject *) 0 ;
28001 PyObject * obj0 = 0 ;
28002 PyObject * obj1 = 0 ;
28003 PyObject * obj2 = 0 ;
28004 char *kwnames[] = {
28005 (char *) "self",(char *) "self",(char *) "_class", NULL
28006 };
28007
28008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28010 if (SWIG_arg_fail(1)) SWIG_fail;
28011 arg2 = obj1;
28012 arg3 = obj2;
28013 {
28014 PyThreadState* __tstate = wxPyBeginAllowThreads();
28015 (arg1)->_setCallbackInfo(arg2,arg3);
28016
28017 wxPyEndAllowThreads(__tstate);
28018 if (PyErr_Occurred()) SWIG_fail;
28019 }
28020 Py_INCREF(Py_None); resultobj = Py_None;
28021 return resultobj;
28022 fail:
28023 return NULL;
28024 }
28025
28026
28027 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28028 PyObject *obj;
28029 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28030 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28031 Py_INCREF(obj);
28032 return Py_BuildValue((char *)"");
28033 }
28034 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28035 PyObject *resultobj;
28036 wxFileDataObject *result;
28037 char *kwnames[] = {
28038 NULL
28039 };
28040
28041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28042 {
28043 PyThreadState* __tstate = wxPyBeginAllowThreads();
28044 result = (wxFileDataObject *)new wxFileDataObject();
28045
28046 wxPyEndAllowThreads(__tstate);
28047 if (PyErr_Occurred()) SWIG_fail;
28048 }
28049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28050 return resultobj;
28051 fail:
28052 return NULL;
28053 }
28054
28055
28056 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28057 PyObject *resultobj;
28058 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28059 wxArrayString *result;
28060 PyObject * obj0 = 0 ;
28061 char *kwnames[] = {
28062 (char *) "self", NULL
28063 };
28064
28065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28067 if (SWIG_arg_fail(1)) SWIG_fail;
28068 {
28069 PyThreadState* __tstate = wxPyBeginAllowThreads();
28070 {
28071 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28072 result = (wxArrayString *) &_result_ref;
28073 }
28074
28075 wxPyEndAllowThreads(__tstate);
28076 if (PyErr_Occurred()) SWIG_fail;
28077 }
28078 {
28079 resultobj = wxArrayString2PyList_helper(*result);
28080 }
28081 return resultobj;
28082 fail:
28083 return NULL;
28084 }
28085
28086
28087 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28088 PyObject *resultobj;
28089 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28090 wxString *arg2 = 0 ;
28091 bool temp2 = false ;
28092 PyObject * obj0 = 0 ;
28093 PyObject * obj1 = 0 ;
28094 char *kwnames[] = {
28095 (char *) "self",(char *) "filename", NULL
28096 };
28097
28098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28100 if (SWIG_arg_fail(1)) SWIG_fail;
28101 {
28102 arg2 = wxString_in_helper(obj1);
28103 if (arg2 == NULL) SWIG_fail;
28104 temp2 = true;
28105 }
28106 {
28107 PyThreadState* __tstate = wxPyBeginAllowThreads();
28108 (arg1)->AddFile((wxString const &)*arg2);
28109
28110 wxPyEndAllowThreads(__tstate);
28111 if (PyErr_Occurred()) SWIG_fail;
28112 }
28113 Py_INCREF(Py_None); resultobj = Py_None;
28114 {
28115 if (temp2)
28116 delete arg2;
28117 }
28118 return resultobj;
28119 fail:
28120 {
28121 if (temp2)
28122 delete arg2;
28123 }
28124 return NULL;
28125 }
28126
28127
28128 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28129 PyObject *obj;
28130 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28131 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28132 Py_INCREF(obj);
28133 return Py_BuildValue((char *)"");
28134 }
28135 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28136 PyObject *resultobj;
28137 wxDataFormat *arg1 = 0 ;
28138 wxCustomDataObject *result;
28139 PyObject * obj0 = 0 ;
28140
28141 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28142 {
28143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28144 if (SWIG_arg_fail(1)) SWIG_fail;
28145 if (arg1 == NULL) {
28146 SWIG_null_ref("wxDataFormat");
28147 }
28148 if (SWIG_arg_fail(1)) SWIG_fail;
28149 }
28150 {
28151 PyThreadState* __tstate = wxPyBeginAllowThreads();
28152 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28153
28154 wxPyEndAllowThreads(__tstate);
28155 if (PyErr_Occurred()) SWIG_fail;
28156 }
28157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28158 return resultobj;
28159 fail:
28160 return NULL;
28161 }
28162
28163
28164 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28165 PyObject *resultobj;
28166 wxString *arg1 = 0 ;
28167 wxCustomDataObject *result;
28168 bool temp1 = false ;
28169 PyObject * obj0 = 0 ;
28170
28171 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28172 {
28173 arg1 = wxString_in_helper(obj0);
28174 if (arg1 == NULL) SWIG_fail;
28175 temp1 = true;
28176 }
28177 {
28178 PyThreadState* __tstate = wxPyBeginAllowThreads();
28179 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28180
28181 wxPyEndAllowThreads(__tstate);
28182 if (PyErr_Occurred()) SWIG_fail;
28183 }
28184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28185 {
28186 if (temp1)
28187 delete arg1;
28188 }
28189 return resultobj;
28190 fail:
28191 {
28192 if (temp1)
28193 delete arg1;
28194 }
28195 return NULL;
28196 }
28197
28198
28199 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28200 PyObject *resultobj;
28201 wxCustomDataObject *result;
28202
28203 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28204 {
28205 PyThreadState* __tstate = wxPyBeginAllowThreads();
28206 result = (wxCustomDataObject *)new wxCustomDataObject();
28207
28208 wxPyEndAllowThreads(__tstate);
28209 if (PyErr_Occurred()) SWIG_fail;
28210 }
28211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28212 return resultobj;
28213 fail:
28214 return NULL;
28215 }
28216
28217
28218 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28219 int argc;
28220 PyObject *argv[2];
28221 int ii;
28222
28223 argc = PyObject_Length(args);
28224 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28225 argv[ii] = PyTuple_GetItem(args,ii);
28226 }
28227 if (argc == 0) {
28228 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28229 }
28230 if (argc == 1) {
28231 int _v;
28232 {
28233 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28234 }
28235 if (_v) {
28236 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28237 }
28238 }
28239 if (argc == 1) {
28240 int _v;
28241 {
28242 void *ptr = 0;
28243 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28244 _v = 0;
28245 PyErr_Clear();
28246 } else {
28247 _v = (ptr != 0);
28248 }
28249 }
28250 if (_v) {
28251 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28252 }
28253 }
28254
28255 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28256 return NULL;
28257 }
28258
28259
28260 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28261 PyObject *resultobj;
28262 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28263 PyObject *arg2 = (PyObject *) 0 ;
28264 bool result;
28265 PyObject * obj0 = 0 ;
28266 PyObject * obj1 = 0 ;
28267 char *kwnames[] = {
28268 (char *) "self",(char *) "data", NULL
28269 };
28270
28271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28273 if (SWIG_arg_fail(1)) SWIG_fail;
28274 arg2 = obj1;
28275 {
28276 PyThreadState* __tstate = wxPyBeginAllowThreads();
28277 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28278
28279 wxPyEndAllowThreads(__tstate);
28280 if (PyErr_Occurred()) SWIG_fail;
28281 }
28282 {
28283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28284 }
28285 return resultobj;
28286 fail:
28287 return NULL;
28288 }
28289
28290
28291 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28292 PyObject *resultobj;
28293 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28294 size_t result;
28295 PyObject * obj0 = 0 ;
28296 char *kwnames[] = {
28297 (char *) "self", NULL
28298 };
28299
28300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28302 if (SWIG_arg_fail(1)) SWIG_fail;
28303 {
28304 PyThreadState* __tstate = wxPyBeginAllowThreads();
28305 result = (size_t)(arg1)->GetSize();
28306
28307 wxPyEndAllowThreads(__tstate);
28308 if (PyErr_Occurred()) SWIG_fail;
28309 }
28310 {
28311 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28312 }
28313 return resultobj;
28314 fail:
28315 return NULL;
28316 }
28317
28318
28319 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28320 PyObject *resultobj;
28321 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28322 PyObject *result;
28323 PyObject * obj0 = 0 ;
28324 char *kwnames[] = {
28325 (char *) "self", NULL
28326 };
28327
28328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28330 if (SWIG_arg_fail(1)) SWIG_fail;
28331 {
28332 PyThreadState* __tstate = wxPyBeginAllowThreads();
28333 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28334
28335 wxPyEndAllowThreads(__tstate);
28336 if (PyErr_Occurred()) SWIG_fail;
28337 }
28338 resultobj = result;
28339 return resultobj;
28340 fail:
28341 return NULL;
28342 }
28343
28344
28345 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28346 PyObject *obj;
28347 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28348 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28349 Py_INCREF(obj);
28350 return Py_BuildValue((char *)"");
28351 }
28352 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28353 PyObject *resultobj;
28354 wxURLDataObject *result;
28355 char *kwnames[] = {
28356 NULL
28357 };
28358
28359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28360 {
28361 PyThreadState* __tstate = wxPyBeginAllowThreads();
28362 result = (wxURLDataObject *)new wxURLDataObject();
28363
28364 wxPyEndAllowThreads(__tstate);
28365 if (PyErr_Occurred()) SWIG_fail;
28366 }
28367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28368 return resultobj;
28369 fail:
28370 return NULL;
28371 }
28372
28373
28374 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28375 PyObject *resultobj;
28376 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28377 wxString result;
28378 PyObject * obj0 = 0 ;
28379 char *kwnames[] = {
28380 (char *) "self", NULL
28381 };
28382
28383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28385 if (SWIG_arg_fail(1)) SWIG_fail;
28386 {
28387 PyThreadState* __tstate = wxPyBeginAllowThreads();
28388 result = (arg1)->GetURL();
28389
28390 wxPyEndAllowThreads(__tstate);
28391 if (PyErr_Occurred()) SWIG_fail;
28392 }
28393 {
28394 #if wxUSE_UNICODE
28395 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28396 #else
28397 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28398 #endif
28399 }
28400 return resultobj;
28401 fail:
28402 return NULL;
28403 }
28404
28405
28406 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28407 PyObject *resultobj;
28408 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28409 wxString *arg2 = 0 ;
28410 bool temp2 = false ;
28411 PyObject * obj0 = 0 ;
28412 PyObject * obj1 = 0 ;
28413 char *kwnames[] = {
28414 (char *) "self",(char *) "url", NULL
28415 };
28416
28417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28419 if (SWIG_arg_fail(1)) SWIG_fail;
28420 {
28421 arg2 = wxString_in_helper(obj1);
28422 if (arg2 == NULL) SWIG_fail;
28423 temp2 = true;
28424 }
28425 {
28426 PyThreadState* __tstate = wxPyBeginAllowThreads();
28427 (arg1)->SetURL((wxString const &)*arg2);
28428
28429 wxPyEndAllowThreads(__tstate);
28430 if (PyErr_Occurred()) SWIG_fail;
28431 }
28432 Py_INCREF(Py_None); resultobj = Py_None;
28433 {
28434 if (temp2)
28435 delete arg2;
28436 }
28437 return resultobj;
28438 fail:
28439 {
28440 if (temp2)
28441 delete arg2;
28442 }
28443 return NULL;
28444 }
28445
28446
28447 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28448 PyObject *obj;
28449 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28450 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28451 Py_INCREF(obj);
28452 return Py_BuildValue((char *)"");
28453 }
28454 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28455 PyObject *resultobj;
28456 wxMetafileDataObject *result;
28457 char *kwnames[] = {
28458 NULL
28459 };
28460
28461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28462 {
28463 PyThreadState* __tstate = wxPyBeginAllowThreads();
28464 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28465
28466 wxPyEndAllowThreads(__tstate);
28467 if (PyErr_Occurred()) SWIG_fail;
28468 }
28469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28470 return resultobj;
28471 fail:
28472 return NULL;
28473 }
28474
28475
28476 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28477 PyObject *resultobj;
28478 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28479 wxMetafile *arg2 = 0 ;
28480 PyObject * obj0 = 0 ;
28481 PyObject * obj1 = 0 ;
28482 char *kwnames[] = {
28483 (char *) "self",(char *) "metafile", NULL
28484 };
28485
28486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28488 if (SWIG_arg_fail(1)) SWIG_fail;
28489 {
28490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28491 if (SWIG_arg_fail(2)) SWIG_fail;
28492 if (arg2 == NULL) {
28493 SWIG_null_ref("wxMetafile");
28494 }
28495 if (SWIG_arg_fail(2)) SWIG_fail;
28496 }
28497 {
28498 PyThreadState* __tstate = wxPyBeginAllowThreads();
28499 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28500
28501 wxPyEndAllowThreads(__tstate);
28502 if (PyErr_Occurred()) SWIG_fail;
28503 }
28504 Py_INCREF(Py_None); resultobj = Py_None;
28505 return resultobj;
28506 fail:
28507 return NULL;
28508 }
28509
28510
28511 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28512 PyObject *resultobj;
28513 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28514 wxMetafile result;
28515 PyObject * obj0 = 0 ;
28516 char *kwnames[] = {
28517 (char *) "self", NULL
28518 };
28519
28520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28522 if (SWIG_arg_fail(1)) SWIG_fail;
28523 {
28524 PyThreadState* __tstate = wxPyBeginAllowThreads();
28525 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28526
28527 wxPyEndAllowThreads(__tstate);
28528 if (PyErr_Occurred()) SWIG_fail;
28529 }
28530 {
28531 wxMetafile * resultptr;
28532 resultptr = new wxMetafile((wxMetafile &)(result));
28533 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28534 }
28535 return resultobj;
28536 fail:
28537 return NULL;
28538 }
28539
28540
28541 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28542 PyObject *obj;
28543 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28544 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28545 Py_INCREF(obj);
28546 return Py_BuildValue((char *)"");
28547 }
28548 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28549 PyObject *resultobj;
28550 wxDragResult arg1 ;
28551 bool result;
28552 PyObject * obj0 = 0 ;
28553 char *kwnames[] = {
28554 (char *) "res", NULL
28555 };
28556
28557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28558 {
28559 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28560 if (SWIG_arg_fail(1)) SWIG_fail;
28561 }
28562 {
28563 PyThreadState* __tstate = wxPyBeginAllowThreads();
28564 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28565
28566 wxPyEndAllowThreads(__tstate);
28567 if (PyErr_Occurred()) SWIG_fail;
28568 }
28569 {
28570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28571 }
28572 return resultobj;
28573 fail:
28574 return NULL;
28575 }
28576
28577
28578 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28579 PyObject *resultobj;
28580 wxWindow *arg1 = (wxWindow *) 0 ;
28581 wxCursor const &arg2_defvalue = wxNullCursor ;
28582 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28583 wxCursor const &arg3_defvalue = wxNullCursor ;
28584 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28585 wxCursor const &arg4_defvalue = wxNullCursor ;
28586 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28587 wxPyDropSource *result;
28588 PyObject * obj0 = 0 ;
28589 PyObject * obj1 = 0 ;
28590 PyObject * obj2 = 0 ;
28591 PyObject * obj3 = 0 ;
28592 char *kwnames[] = {
28593 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28594 };
28595
28596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28598 if (SWIG_arg_fail(1)) SWIG_fail;
28599 if (obj1) {
28600 {
28601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28602 if (SWIG_arg_fail(2)) SWIG_fail;
28603 if (arg2 == NULL) {
28604 SWIG_null_ref("wxCursor");
28605 }
28606 if (SWIG_arg_fail(2)) SWIG_fail;
28607 }
28608 }
28609 if (obj2) {
28610 {
28611 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28612 if (SWIG_arg_fail(3)) SWIG_fail;
28613 if (arg3 == NULL) {
28614 SWIG_null_ref("wxCursor");
28615 }
28616 if (SWIG_arg_fail(3)) SWIG_fail;
28617 }
28618 }
28619 if (obj3) {
28620 {
28621 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28622 if (SWIG_arg_fail(4)) SWIG_fail;
28623 if (arg4 == NULL) {
28624 SWIG_null_ref("wxCursor");
28625 }
28626 if (SWIG_arg_fail(4)) SWIG_fail;
28627 }
28628 }
28629 {
28630 PyThreadState* __tstate = wxPyBeginAllowThreads();
28631 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28632
28633 wxPyEndAllowThreads(__tstate);
28634 if (PyErr_Occurred()) SWIG_fail;
28635 }
28636 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28637 return resultobj;
28638 fail:
28639 return NULL;
28640 }
28641
28642
28643 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28644 PyObject *resultobj;
28645 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28646 PyObject *arg2 = (PyObject *) 0 ;
28647 PyObject *arg3 = (PyObject *) 0 ;
28648 int arg4 ;
28649 PyObject * obj0 = 0 ;
28650 PyObject * obj1 = 0 ;
28651 PyObject * obj2 = 0 ;
28652 PyObject * obj3 = 0 ;
28653 char *kwnames[] = {
28654 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28655 };
28656
28657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28659 if (SWIG_arg_fail(1)) SWIG_fail;
28660 arg2 = obj1;
28661 arg3 = obj2;
28662 {
28663 arg4 = (int)(SWIG_As_int(obj3));
28664 if (SWIG_arg_fail(4)) SWIG_fail;
28665 }
28666 {
28667 PyThreadState* __tstate = wxPyBeginAllowThreads();
28668 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28669
28670 wxPyEndAllowThreads(__tstate);
28671 if (PyErr_Occurred()) SWIG_fail;
28672 }
28673 Py_INCREF(Py_None); resultobj = Py_None;
28674 return resultobj;
28675 fail:
28676 return NULL;
28677 }
28678
28679
28680 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28681 PyObject *resultobj;
28682 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28683 PyObject * obj0 = 0 ;
28684 char *kwnames[] = {
28685 (char *) "self", NULL
28686 };
28687
28688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28690 if (SWIG_arg_fail(1)) SWIG_fail;
28691 {
28692 PyThreadState* __tstate = wxPyBeginAllowThreads();
28693 delete arg1;
28694
28695 wxPyEndAllowThreads(__tstate);
28696 if (PyErr_Occurred()) SWIG_fail;
28697 }
28698 Py_INCREF(Py_None); resultobj = Py_None;
28699 return resultobj;
28700 fail:
28701 return NULL;
28702 }
28703
28704
28705 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28706 PyObject *resultobj;
28707 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28708 wxDataObject *arg2 = 0 ;
28709 PyObject * obj0 = 0 ;
28710 PyObject * obj1 = 0 ;
28711 char *kwnames[] = {
28712 (char *) "self",(char *) "data", NULL
28713 };
28714
28715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28717 if (SWIG_arg_fail(1)) SWIG_fail;
28718 {
28719 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28720 if (SWIG_arg_fail(2)) SWIG_fail;
28721 if (arg2 == NULL) {
28722 SWIG_null_ref("wxDataObject");
28723 }
28724 if (SWIG_arg_fail(2)) SWIG_fail;
28725 }
28726 {
28727 PyThreadState* __tstate = wxPyBeginAllowThreads();
28728 (arg1)->SetData(*arg2);
28729
28730 wxPyEndAllowThreads(__tstate);
28731 if (PyErr_Occurred()) SWIG_fail;
28732 }
28733 Py_INCREF(Py_None); resultobj = Py_None;
28734 return resultobj;
28735 fail:
28736 return NULL;
28737 }
28738
28739
28740 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28741 PyObject *resultobj;
28742 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28743 wxDataObject *result;
28744 PyObject * obj0 = 0 ;
28745 char *kwnames[] = {
28746 (char *) "self", NULL
28747 };
28748
28749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
28754 result = (wxDataObject *)(arg1)->GetDataObject();
28755
28756 wxPyEndAllowThreads(__tstate);
28757 if (PyErr_Occurred()) SWIG_fail;
28758 }
28759 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28760 return resultobj;
28761 fail:
28762 return NULL;
28763 }
28764
28765
28766 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28767 PyObject *resultobj;
28768 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28769 wxDragResult arg2 ;
28770 wxCursor *arg3 = 0 ;
28771 PyObject * obj0 = 0 ;
28772 PyObject * obj1 = 0 ;
28773 PyObject * obj2 = 0 ;
28774 char *kwnames[] = {
28775 (char *) "self",(char *) "res",(char *) "cursor", NULL
28776 };
28777
28778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28780 if (SWIG_arg_fail(1)) SWIG_fail;
28781 {
28782 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28783 if (SWIG_arg_fail(2)) SWIG_fail;
28784 }
28785 {
28786 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28787 if (SWIG_arg_fail(3)) SWIG_fail;
28788 if (arg3 == NULL) {
28789 SWIG_null_ref("wxCursor");
28790 }
28791 if (SWIG_arg_fail(3)) SWIG_fail;
28792 }
28793 {
28794 PyThreadState* __tstate = wxPyBeginAllowThreads();
28795 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28796
28797 wxPyEndAllowThreads(__tstate);
28798 if (PyErr_Occurred()) SWIG_fail;
28799 }
28800 Py_INCREF(Py_None); resultobj = Py_None;
28801 return resultobj;
28802 fail:
28803 return NULL;
28804 }
28805
28806
28807 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28808 PyObject *resultobj;
28809 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28810 int arg2 = (int) wxDrag_CopyOnly ;
28811 wxDragResult result;
28812 PyObject * obj0 = 0 ;
28813 PyObject * obj1 = 0 ;
28814 char *kwnames[] = {
28815 (char *) "self",(char *) "flags", NULL
28816 };
28817
28818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28820 if (SWIG_arg_fail(1)) SWIG_fail;
28821 if (obj1) {
28822 {
28823 arg2 = (int)(SWIG_As_int(obj1));
28824 if (SWIG_arg_fail(2)) SWIG_fail;
28825 }
28826 }
28827 {
28828 PyThreadState* __tstate = wxPyBeginAllowThreads();
28829 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28830
28831 wxPyEndAllowThreads(__tstate);
28832 if (PyErr_Occurred()) SWIG_fail;
28833 }
28834 resultobj = SWIG_From_int((result));
28835 return resultobj;
28836 fail:
28837 return NULL;
28838 }
28839
28840
28841 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28842 PyObject *resultobj;
28843 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28844 wxDragResult arg2 ;
28845 bool result;
28846 PyObject * obj0 = 0 ;
28847 PyObject * obj1 = 0 ;
28848 char *kwnames[] = {
28849 (char *) "self",(char *) "effect", NULL
28850 };
28851
28852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",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 {
28856 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28857 if (SWIG_arg_fail(2)) SWIG_fail;
28858 }
28859 {
28860 PyThreadState* __tstate = wxPyBeginAllowThreads();
28861 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28862
28863 wxPyEndAllowThreads(__tstate);
28864 if (PyErr_Occurred()) SWIG_fail;
28865 }
28866 {
28867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28868 }
28869 return resultobj;
28870 fail:
28871 return NULL;
28872 }
28873
28874
28875 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28876 PyObject *obj;
28877 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28878 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28879 Py_INCREF(obj);
28880 return Py_BuildValue((char *)"");
28881 }
28882 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28883 PyObject *resultobj;
28884 wxDataObject *arg1 = (wxDataObject *) NULL ;
28885 wxPyDropTarget *result;
28886 PyObject * obj0 = 0 ;
28887 char *kwnames[] = {
28888 (char *) "dataObject", NULL
28889 };
28890
28891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28892 if (obj0) {
28893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28894 if (SWIG_arg_fail(1)) SWIG_fail;
28895 }
28896 {
28897 PyThreadState* __tstate = wxPyBeginAllowThreads();
28898 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28899
28900 wxPyEndAllowThreads(__tstate);
28901 if (PyErr_Occurred()) SWIG_fail;
28902 }
28903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28904 return resultobj;
28905 fail:
28906 return NULL;
28907 }
28908
28909
28910 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28911 PyObject *resultobj;
28912 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28913 PyObject *arg2 = (PyObject *) 0 ;
28914 PyObject *arg3 = (PyObject *) 0 ;
28915 PyObject * obj0 = 0 ;
28916 PyObject * obj1 = 0 ;
28917 PyObject * obj2 = 0 ;
28918 char *kwnames[] = {
28919 (char *) "self",(char *) "self",(char *) "_class", NULL
28920 };
28921
28922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28924 if (SWIG_arg_fail(1)) SWIG_fail;
28925 arg2 = obj1;
28926 arg3 = obj2;
28927 {
28928 PyThreadState* __tstate = wxPyBeginAllowThreads();
28929 (arg1)->_setCallbackInfo(arg2,arg3);
28930
28931 wxPyEndAllowThreads(__tstate);
28932 if (PyErr_Occurred()) SWIG_fail;
28933 }
28934 Py_INCREF(Py_None); resultobj = Py_None;
28935 return resultobj;
28936 fail:
28937 return NULL;
28938 }
28939
28940
28941 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28942 PyObject *resultobj;
28943 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28944 PyObject * obj0 = 0 ;
28945 char *kwnames[] = {
28946 (char *) "self", NULL
28947 };
28948
28949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28951 if (SWIG_arg_fail(1)) SWIG_fail;
28952 {
28953 PyThreadState* __tstate = wxPyBeginAllowThreads();
28954 delete arg1;
28955
28956 wxPyEndAllowThreads(__tstate);
28957 if (PyErr_Occurred()) SWIG_fail;
28958 }
28959 Py_INCREF(Py_None); resultobj = Py_None;
28960 return resultobj;
28961 fail:
28962 return NULL;
28963 }
28964
28965
28966 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28967 PyObject *resultobj;
28968 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28969 wxDataObject *result;
28970 PyObject * obj0 = 0 ;
28971 char *kwnames[] = {
28972 (char *) "self", NULL
28973 };
28974
28975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28977 if (SWIG_arg_fail(1)) SWIG_fail;
28978 {
28979 PyThreadState* __tstate = wxPyBeginAllowThreads();
28980 result = (wxDataObject *)(arg1)->GetDataObject();
28981
28982 wxPyEndAllowThreads(__tstate);
28983 if (PyErr_Occurred()) SWIG_fail;
28984 }
28985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28986 return resultobj;
28987 fail:
28988 return NULL;
28989 }
28990
28991
28992 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28993 PyObject *resultobj;
28994 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28995 wxDataObject *arg2 = (wxDataObject *) 0 ;
28996 PyObject * obj0 = 0 ;
28997 PyObject * obj1 = 0 ;
28998 char *kwnames[] = {
28999 (char *) "self",(char *) "dataObject", NULL
29000 };
29001
29002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29004 if (SWIG_arg_fail(1)) SWIG_fail;
29005 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29006 if (SWIG_arg_fail(2)) SWIG_fail;
29007 {
29008 PyThreadState* __tstate = wxPyBeginAllowThreads();
29009 (arg1)->SetDataObject(arg2);
29010
29011 wxPyEndAllowThreads(__tstate);
29012 if (PyErr_Occurred()) SWIG_fail;
29013 }
29014 Py_INCREF(Py_None); resultobj = Py_None;
29015 return resultobj;
29016 fail:
29017 return NULL;
29018 }
29019
29020
29021 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29022 PyObject *resultobj;
29023 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29024 int arg2 ;
29025 int arg3 ;
29026 wxDragResult arg4 ;
29027 wxDragResult result;
29028 PyObject * obj0 = 0 ;
29029 PyObject * obj1 = 0 ;
29030 PyObject * obj2 = 0 ;
29031 PyObject * obj3 = 0 ;
29032 char *kwnames[] = {
29033 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29034 };
29035
29036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 {
29040 arg2 = (int)(SWIG_As_int(obj1));
29041 if (SWIG_arg_fail(2)) SWIG_fail;
29042 }
29043 {
29044 arg3 = (int)(SWIG_As_int(obj2));
29045 if (SWIG_arg_fail(3)) SWIG_fail;
29046 }
29047 {
29048 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29049 if (SWIG_arg_fail(4)) SWIG_fail;
29050 }
29051 {
29052 PyThreadState* __tstate = wxPyBeginAllowThreads();
29053 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29054
29055 wxPyEndAllowThreads(__tstate);
29056 if (PyErr_Occurred()) SWIG_fail;
29057 }
29058 resultobj = SWIG_From_int((result));
29059 return resultobj;
29060 fail:
29061 return NULL;
29062 }
29063
29064
29065 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29066 PyObject *resultobj;
29067 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29068 int arg2 ;
29069 int arg3 ;
29070 wxDragResult arg4 ;
29071 wxDragResult result;
29072 PyObject * obj0 = 0 ;
29073 PyObject * obj1 = 0 ;
29074 PyObject * obj2 = 0 ;
29075 PyObject * obj3 = 0 ;
29076 char *kwnames[] = {
29077 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29078 };
29079
29080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29082 if (SWIG_arg_fail(1)) SWIG_fail;
29083 {
29084 arg2 = (int)(SWIG_As_int(obj1));
29085 if (SWIG_arg_fail(2)) SWIG_fail;
29086 }
29087 {
29088 arg3 = (int)(SWIG_As_int(obj2));
29089 if (SWIG_arg_fail(3)) SWIG_fail;
29090 }
29091 {
29092 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29093 if (SWIG_arg_fail(4)) SWIG_fail;
29094 }
29095 {
29096 PyThreadState* __tstate = wxPyBeginAllowThreads();
29097 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29098
29099 wxPyEndAllowThreads(__tstate);
29100 if (PyErr_Occurred()) SWIG_fail;
29101 }
29102 resultobj = SWIG_From_int((result));
29103 return resultobj;
29104 fail:
29105 return NULL;
29106 }
29107
29108
29109 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29110 PyObject *resultobj;
29111 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29112 PyObject * obj0 = 0 ;
29113 char *kwnames[] = {
29114 (char *) "self", NULL
29115 };
29116
29117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29119 if (SWIG_arg_fail(1)) SWIG_fail;
29120 {
29121 PyThreadState* __tstate = wxPyBeginAllowThreads();
29122 (arg1)->base_OnLeave();
29123
29124 wxPyEndAllowThreads(__tstate);
29125 if (PyErr_Occurred()) SWIG_fail;
29126 }
29127 Py_INCREF(Py_None); resultobj = Py_None;
29128 return resultobj;
29129 fail:
29130 return NULL;
29131 }
29132
29133
29134 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29135 PyObject *resultobj;
29136 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29137 int arg2 ;
29138 int arg3 ;
29139 bool result;
29140 PyObject * obj0 = 0 ;
29141 PyObject * obj1 = 0 ;
29142 PyObject * obj2 = 0 ;
29143 char *kwnames[] = {
29144 (char *) "self",(char *) "x",(char *) "y", NULL
29145 };
29146
29147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29149 if (SWIG_arg_fail(1)) SWIG_fail;
29150 {
29151 arg2 = (int)(SWIG_As_int(obj1));
29152 if (SWIG_arg_fail(2)) SWIG_fail;
29153 }
29154 {
29155 arg3 = (int)(SWIG_As_int(obj2));
29156 if (SWIG_arg_fail(3)) SWIG_fail;
29157 }
29158 {
29159 PyThreadState* __tstate = wxPyBeginAllowThreads();
29160 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29161
29162 wxPyEndAllowThreads(__tstate);
29163 if (PyErr_Occurred()) SWIG_fail;
29164 }
29165 {
29166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29167 }
29168 return resultobj;
29169 fail:
29170 return NULL;
29171 }
29172
29173
29174 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29175 PyObject *resultobj;
29176 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29177 bool result;
29178 PyObject * obj0 = 0 ;
29179 char *kwnames[] = {
29180 (char *) "self", NULL
29181 };
29182
29183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29185 if (SWIG_arg_fail(1)) SWIG_fail;
29186 {
29187 PyThreadState* __tstate = wxPyBeginAllowThreads();
29188 result = (bool)(arg1)->GetData();
29189
29190 wxPyEndAllowThreads(__tstate);
29191 if (PyErr_Occurred()) SWIG_fail;
29192 }
29193 {
29194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29195 }
29196 return resultobj;
29197 fail:
29198 return NULL;
29199 }
29200
29201
29202 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29203 PyObject *resultobj;
29204 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29205 wxDragResult arg2 ;
29206 PyObject * obj0 = 0 ;
29207 PyObject * obj1 = 0 ;
29208 char *kwnames[] = {
29209 (char *) "self",(char *) "action", NULL
29210 };
29211
29212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29214 if (SWIG_arg_fail(1)) SWIG_fail;
29215 {
29216 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29217 if (SWIG_arg_fail(2)) SWIG_fail;
29218 }
29219 {
29220 PyThreadState* __tstate = wxPyBeginAllowThreads();
29221 (arg1)->SetDefaultAction((wxDragResult )arg2);
29222
29223 wxPyEndAllowThreads(__tstate);
29224 if (PyErr_Occurred()) SWIG_fail;
29225 }
29226 Py_INCREF(Py_None); resultobj = Py_None;
29227 return resultobj;
29228 fail:
29229 return NULL;
29230 }
29231
29232
29233 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29234 PyObject *resultobj;
29235 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29236 wxDragResult result;
29237 PyObject * obj0 = 0 ;
29238 char *kwnames[] = {
29239 (char *) "self", NULL
29240 };
29241
29242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29244 if (SWIG_arg_fail(1)) SWIG_fail;
29245 {
29246 PyThreadState* __tstate = wxPyBeginAllowThreads();
29247 result = (wxDragResult)(arg1)->GetDefaultAction();
29248
29249 wxPyEndAllowThreads(__tstate);
29250 if (PyErr_Occurred()) SWIG_fail;
29251 }
29252 resultobj = SWIG_From_int((result));
29253 return resultobj;
29254 fail:
29255 return NULL;
29256 }
29257
29258
29259 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29260 PyObject *obj;
29261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29262 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29263 Py_INCREF(obj);
29264 return Py_BuildValue((char *)"");
29265 }
29266 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29267 PyObject *resultobj;
29268 wxPyTextDropTarget *result;
29269 char *kwnames[] = {
29270 NULL
29271 };
29272
29273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29274 {
29275 PyThreadState* __tstate = wxPyBeginAllowThreads();
29276 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29277
29278 wxPyEndAllowThreads(__tstate);
29279 if (PyErr_Occurred()) SWIG_fail;
29280 }
29281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29282 return resultobj;
29283 fail:
29284 return NULL;
29285 }
29286
29287
29288 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29289 PyObject *resultobj;
29290 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29291 PyObject *arg2 = (PyObject *) 0 ;
29292 PyObject *arg3 = (PyObject *) 0 ;
29293 PyObject * obj0 = 0 ;
29294 PyObject * obj1 = 0 ;
29295 PyObject * obj2 = 0 ;
29296 char *kwnames[] = {
29297 (char *) "self",(char *) "self",(char *) "_class", NULL
29298 };
29299
29300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29302 if (SWIG_arg_fail(1)) SWIG_fail;
29303 arg2 = obj1;
29304 arg3 = obj2;
29305 {
29306 PyThreadState* __tstate = wxPyBeginAllowThreads();
29307 (arg1)->_setCallbackInfo(arg2,arg3);
29308
29309 wxPyEndAllowThreads(__tstate);
29310 if (PyErr_Occurred()) SWIG_fail;
29311 }
29312 Py_INCREF(Py_None); resultobj = Py_None;
29313 return resultobj;
29314 fail:
29315 return NULL;
29316 }
29317
29318
29319 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29320 PyObject *resultobj;
29321 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29322 int arg2 ;
29323 int arg3 ;
29324 wxDragResult arg4 ;
29325 wxDragResult result;
29326 PyObject * obj0 = 0 ;
29327 PyObject * obj1 = 0 ;
29328 PyObject * obj2 = 0 ;
29329 PyObject * obj3 = 0 ;
29330 char *kwnames[] = {
29331 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29332 };
29333
29334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 {
29338 arg2 = (int)(SWIG_As_int(obj1));
29339 if (SWIG_arg_fail(2)) SWIG_fail;
29340 }
29341 {
29342 arg3 = (int)(SWIG_As_int(obj2));
29343 if (SWIG_arg_fail(3)) SWIG_fail;
29344 }
29345 {
29346 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29347 if (SWIG_arg_fail(4)) SWIG_fail;
29348 }
29349 {
29350 PyThreadState* __tstate = wxPyBeginAllowThreads();
29351 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29352
29353 wxPyEndAllowThreads(__tstate);
29354 if (PyErr_Occurred()) SWIG_fail;
29355 }
29356 resultobj = SWIG_From_int((result));
29357 return resultobj;
29358 fail:
29359 return NULL;
29360 }
29361
29362
29363 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29364 PyObject *resultobj;
29365 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29366 int arg2 ;
29367 int arg3 ;
29368 wxDragResult arg4 ;
29369 wxDragResult result;
29370 PyObject * obj0 = 0 ;
29371 PyObject * obj1 = 0 ;
29372 PyObject * obj2 = 0 ;
29373 PyObject * obj3 = 0 ;
29374 char *kwnames[] = {
29375 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29376 };
29377
29378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29380 if (SWIG_arg_fail(1)) SWIG_fail;
29381 {
29382 arg2 = (int)(SWIG_As_int(obj1));
29383 if (SWIG_arg_fail(2)) SWIG_fail;
29384 }
29385 {
29386 arg3 = (int)(SWIG_As_int(obj2));
29387 if (SWIG_arg_fail(3)) SWIG_fail;
29388 }
29389 {
29390 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29391 if (SWIG_arg_fail(4)) SWIG_fail;
29392 }
29393 {
29394 PyThreadState* __tstate = wxPyBeginAllowThreads();
29395 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29396
29397 wxPyEndAllowThreads(__tstate);
29398 if (PyErr_Occurred()) SWIG_fail;
29399 }
29400 resultobj = SWIG_From_int((result));
29401 return resultobj;
29402 fail:
29403 return NULL;
29404 }
29405
29406
29407 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29408 PyObject *resultobj;
29409 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29410 PyObject * obj0 = 0 ;
29411 char *kwnames[] = {
29412 (char *) "self", NULL
29413 };
29414
29415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29417 if (SWIG_arg_fail(1)) SWIG_fail;
29418 {
29419 PyThreadState* __tstate = wxPyBeginAllowThreads();
29420 (arg1)->base_OnLeave();
29421
29422 wxPyEndAllowThreads(__tstate);
29423 if (PyErr_Occurred()) SWIG_fail;
29424 }
29425 Py_INCREF(Py_None); resultobj = Py_None;
29426 return resultobj;
29427 fail:
29428 return NULL;
29429 }
29430
29431
29432 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29433 PyObject *resultobj;
29434 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29435 int arg2 ;
29436 int arg3 ;
29437 bool result;
29438 PyObject * obj0 = 0 ;
29439 PyObject * obj1 = 0 ;
29440 PyObject * obj2 = 0 ;
29441 char *kwnames[] = {
29442 (char *) "self",(char *) "x",(char *) "y", NULL
29443 };
29444
29445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29447 if (SWIG_arg_fail(1)) SWIG_fail;
29448 {
29449 arg2 = (int)(SWIG_As_int(obj1));
29450 if (SWIG_arg_fail(2)) SWIG_fail;
29451 }
29452 {
29453 arg3 = (int)(SWIG_As_int(obj2));
29454 if (SWIG_arg_fail(3)) SWIG_fail;
29455 }
29456 {
29457 PyThreadState* __tstate = wxPyBeginAllowThreads();
29458 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29459
29460 wxPyEndAllowThreads(__tstate);
29461 if (PyErr_Occurred()) SWIG_fail;
29462 }
29463 {
29464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29465 }
29466 return resultobj;
29467 fail:
29468 return NULL;
29469 }
29470
29471
29472 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29473 PyObject *resultobj;
29474 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29475 int arg2 ;
29476 int arg3 ;
29477 wxDragResult arg4 ;
29478 wxDragResult result;
29479 PyObject * obj0 = 0 ;
29480 PyObject * obj1 = 0 ;
29481 PyObject * obj2 = 0 ;
29482 PyObject * obj3 = 0 ;
29483 char *kwnames[] = {
29484 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29485 };
29486
29487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29489 if (SWIG_arg_fail(1)) SWIG_fail;
29490 {
29491 arg2 = (int)(SWIG_As_int(obj1));
29492 if (SWIG_arg_fail(2)) SWIG_fail;
29493 }
29494 {
29495 arg3 = (int)(SWIG_As_int(obj2));
29496 if (SWIG_arg_fail(3)) SWIG_fail;
29497 }
29498 {
29499 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29500 if (SWIG_arg_fail(4)) SWIG_fail;
29501 }
29502 {
29503 PyThreadState* __tstate = wxPyBeginAllowThreads();
29504 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29505
29506 wxPyEndAllowThreads(__tstate);
29507 if (PyErr_Occurred()) SWIG_fail;
29508 }
29509 resultobj = SWIG_From_int((result));
29510 return resultobj;
29511 fail:
29512 return NULL;
29513 }
29514
29515
29516 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29517 PyObject *obj;
29518 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29519 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29520 Py_INCREF(obj);
29521 return Py_BuildValue((char *)"");
29522 }
29523 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29524 PyObject *resultobj;
29525 wxPyFileDropTarget *result;
29526 char *kwnames[] = {
29527 NULL
29528 };
29529
29530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29531 {
29532 PyThreadState* __tstate = wxPyBeginAllowThreads();
29533 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29534
29535 wxPyEndAllowThreads(__tstate);
29536 if (PyErr_Occurred()) SWIG_fail;
29537 }
29538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29539 return resultobj;
29540 fail:
29541 return NULL;
29542 }
29543
29544
29545 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29546 PyObject *resultobj;
29547 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29548 PyObject *arg2 = (PyObject *) 0 ;
29549 PyObject *arg3 = (PyObject *) 0 ;
29550 PyObject * obj0 = 0 ;
29551 PyObject * obj1 = 0 ;
29552 PyObject * obj2 = 0 ;
29553 char *kwnames[] = {
29554 (char *) "self",(char *) "self",(char *) "_class", NULL
29555 };
29556
29557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29559 if (SWIG_arg_fail(1)) SWIG_fail;
29560 arg2 = obj1;
29561 arg3 = obj2;
29562 {
29563 PyThreadState* __tstate = wxPyBeginAllowThreads();
29564 (arg1)->_setCallbackInfo(arg2,arg3);
29565
29566 wxPyEndAllowThreads(__tstate);
29567 if (PyErr_Occurred()) SWIG_fail;
29568 }
29569 Py_INCREF(Py_None); resultobj = Py_None;
29570 return resultobj;
29571 fail:
29572 return NULL;
29573 }
29574
29575
29576 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29577 PyObject *resultobj;
29578 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29579 int arg2 ;
29580 int arg3 ;
29581 wxDragResult arg4 ;
29582 wxDragResult result;
29583 PyObject * obj0 = 0 ;
29584 PyObject * obj1 = 0 ;
29585 PyObject * obj2 = 0 ;
29586 PyObject * obj3 = 0 ;
29587 char *kwnames[] = {
29588 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29589 };
29590
29591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 {
29595 arg2 = (int)(SWIG_As_int(obj1));
29596 if (SWIG_arg_fail(2)) SWIG_fail;
29597 }
29598 {
29599 arg3 = (int)(SWIG_As_int(obj2));
29600 if (SWIG_arg_fail(3)) SWIG_fail;
29601 }
29602 {
29603 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29604 if (SWIG_arg_fail(4)) SWIG_fail;
29605 }
29606 {
29607 PyThreadState* __tstate = wxPyBeginAllowThreads();
29608 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29609
29610 wxPyEndAllowThreads(__tstate);
29611 if (PyErr_Occurred()) SWIG_fail;
29612 }
29613 resultobj = SWIG_From_int((result));
29614 return resultobj;
29615 fail:
29616 return NULL;
29617 }
29618
29619
29620 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29621 PyObject *resultobj;
29622 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29623 int arg2 ;
29624 int arg3 ;
29625 wxDragResult arg4 ;
29626 wxDragResult result;
29627 PyObject * obj0 = 0 ;
29628 PyObject * obj1 = 0 ;
29629 PyObject * obj2 = 0 ;
29630 PyObject * obj3 = 0 ;
29631 char *kwnames[] = {
29632 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29633 };
29634
29635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29637 if (SWIG_arg_fail(1)) SWIG_fail;
29638 {
29639 arg2 = (int)(SWIG_As_int(obj1));
29640 if (SWIG_arg_fail(2)) SWIG_fail;
29641 }
29642 {
29643 arg3 = (int)(SWIG_As_int(obj2));
29644 if (SWIG_arg_fail(3)) SWIG_fail;
29645 }
29646 {
29647 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29648 if (SWIG_arg_fail(4)) SWIG_fail;
29649 }
29650 {
29651 PyThreadState* __tstate = wxPyBeginAllowThreads();
29652 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29653
29654 wxPyEndAllowThreads(__tstate);
29655 if (PyErr_Occurred()) SWIG_fail;
29656 }
29657 resultobj = SWIG_From_int((result));
29658 return resultobj;
29659 fail:
29660 return NULL;
29661 }
29662
29663
29664 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29665 PyObject *resultobj;
29666 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29667 PyObject * obj0 = 0 ;
29668 char *kwnames[] = {
29669 (char *) "self", NULL
29670 };
29671
29672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29674 if (SWIG_arg_fail(1)) SWIG_fail;
29675 {
29676 PyThreadState* __tstate = wxPyBeginAllowThreads();
29677 (arg1)->base_OnLeave();
29678
29679 wxPyEndAllowThreads(__tstate);
29680 if (PyErr_Occurred()) SWIG_fail;
29681 }
29682 Py_INCREF(Py_None); resultobj = Py_None;
29683 return resultobj;
29684 fail:
29685 return NULL;
29686 }
29687
29688
29689 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29690 PyObject *resultobj;
29691 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29692 int arg2 ;
29693 int arg3 ;
29694 bool result;
29695 PyObject * obj0 = 0 ;
29696 PyObject * obj1 = 0 ;
29697 PyObject * obj2 = 0 ;
29698 char *kwnames[] = {
29699 (char *) "self",(char *) "x",(char *) "y", NULL
29700 };
29701
29702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29704 if (SWIG_arg_fail(1)) SWIG_fail;
29705 {
29706 arg2 = (int)(SWIG_As_int(obj1));
29707 if (SWIG_arg_fail(2)) SWIG_fail;
29708 }
29709 {
29710 arg3 = (int)(SWIG_As_int(obj2));
29711 if (SWIG_arg_fail(3)) SWIG_fail;
29712 }
29713 {
29714 PyThreadState* __tstate = wxPyBeginAllowThreads();
29715 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29716
29717 wxPyEndAllowThreads(__tstate);
29718 if (PyErr_Occurred()) SWIG_fail;
29719 }
29720 {
29721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29722 }
29723 return resultobj;
29724 fail:
29725 return NULL;
29726 }
29727
29728
29729 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29730 PyObject *resultobj;
29731 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29732 int arg2 ;
29733 int arg3 ;
29734 wxDragResult arg4 ;
29735 wxDragResult result;
29736 PyObject * obj0 = 0 ;
29737 PyObject * obj1 = 0 ;
29738 PyObject * obj2 = 0 ;
29739 PyObject * obj3 = 0 ;
29740 char *kwnames[] = {
29741 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29742 };
29743
29744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29746 if (SWIG_arg_fail(1)) SWIG_fail;
29747 {
29748 arg2 = (int)(SWIG_As_int(obj1));
29749 if (SWIG_arg_fail(2)) SWIG_fail;
29750 }
29751 {
29752 arg3 = (int)(SWIG_As_int(obj2));
29753 if (SWIG_arg_fail(3)) SWIG_fail;
29754 }
29755 {
29756 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29757 if (SWIG_arg_fail(4)) SWIG_fail;
29758 }
29759 {
29760 PyThreadState* __tstate = wxPyBeginAllowThreads();
29761 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29762
29763 wxPyEndAllowThreads(__tstate);
29764 if (PyErr_Occurred()) SWIG_fail;
29765 }
29766 resultobj = SWIG_From_int((result));
29767 return resultobj;
29768 fail:
29769 return NULL;
29770 }
29771
29772
29773 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29774 PyObject *obj;
29775 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29776 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29777 Py_INCREF(obj);
29778 return Py_BuildValue((char *)"");
29779 }
29780 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29781 PyObject *resultobj;
29782 wxClipboard *result;
29783 char *kwnames[] = {
29784 NULL
29785 };
29786
29787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29788 {
29789 PyThreadState* __tstate = wxPyBeginAllowThreads();
29790 result = (wxClipboard *)new wxClipboard();
29791
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29796 return resultobj;
29797 fail:
29798 return NULL;
29799 }
29800
29801
29802 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29803 PyObject *resultobj;
29804 wxClipboard *arg1 = (wxClipboard *) 0 ;
29805 PyObject * obj0 = 0 ;
29806 char *kwnames[] = {
29807 (char *) "self", NULL
29808 };
29809
29810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29812 if (SWIG_arg_fail(1)) SWIG_fail;
29813 {
29814 PyThreadState* __tstate = wxPyBeginAllowThreads();
29815 delete arg1;
29816
29817 wxPyEndAllowThreads(__tstate);
29818 if (PyErr_Occurred()) SWIG_fail;
29819 }
29820 Py_INCREF(Py_None); resultobj = Py_None;
29821 return resultobj;
29822 fail:
29823 return NULL;
29824 }
29825
29826
29827 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29828 PyObject *resultobj;
29829 wxClipboard *arg1 = (wxClipboard *) 0 ;
29830 bool result;
29831 PyObject * obj0 = 0 ;
29832 char *kwnames[] = {
29833 (char *) "self", NULL
29834 };
29835
29836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29838 if (SWIG_arg_fail(1)) SWIG_fail;
29839 {
29840 PyThreadState* __tstate = wxPyBeginAllowThreads();
29841 result = (bool)(arg1)->Open();
29842
29843 wxPyEndAllowThreads(__tstate);
29844 if (PyErr_Occurred()) SWIG_fail;
29845 }
29846 {
29847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29848 }
29849 return resultobj;
29850 fail:
29851 return NULL;
29852 }
29853
29854
29855 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29856 PyObject *resultobj;
29857 wxClipboard *arg1 = (wxClipboard *) 0 ;
29858 PyObject * obj0 = 0 ;
29859 char *kwnames[] = {
29860 (char *) "self", NULL
29861 };
29862
29863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29865 if (SWIG_arg_fail(1)) SWIG_fail;
29866 {
29867 PyThreadState* __tstate = wxPyBeginAllowThreads();
29868 (arg1)->Close();
29869
29870 wxPyEndAllowThreads(__tstate);
29871 if (PyErr_Occurred()) SWIG_fail;
29872 }
29873 Py_INCREF(Py_None); resultobj = Py_None;
29874 return resultobj;
29875 fail:
29876 return NULL;
29877 }
29878
29879
29880 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29881 PyObject *resultobj;
29882 wxClipboard *arg1 = (wxClipboard *) 0 ;
29883 bool result;
29884 PyObject * obj0 = 0 ;
29885 char *kwnames[] = {
29886 (char *) "self", NULL
29887 };
29888
29889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29891 if (SWIG_arg_fail(1)) SWIG_fail;
29892 {
29893 PyThreadState* __tstate = wxPyBeginAllowThreads();
29894 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29895
29896 wxPyEndAllowThreads(__tstate);
29897 if (PyErr_Occurred()) SWIG_fail;
29898 }
29899 {
29900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29901 }
29902 return resultobj;
29903 fail:
29904 return NULL;
29905 }
29906
29907
29908 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29909 PyObject *resultobj;
29910 wxClipboard *arg1 = (wxClipboard *) 0 ;
29911 wxDataObject *arg2 = (wxDataObject *) 0 ;
29912 bool result;
29913 PyObject * obj0 = 0 ;
29914 PyObject * obj1 = 0 ;
29915 char *kwnames[] = {
29916 (char *) "self",(char *) "data", NULL
29917 };
29918
29919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29921 if (SWIG_arg_fail(1)) SWIG_fail;
29922 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29923 if (SWIG_arg_fail(2)) SWIG_fail;
29924 {
29925 PyThreadState* __tstate = wxPyBeginAllowThreads();
29926 result = (bool)(arg1)->AddData(arg2);
29927
29928 wxPyEndAllowThreads(__tstate);
29929 if (PyErr_Occurred()) SWIG_fail;
29930 }
29931 {
29932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29933 }
29934 return resultobj;
29935 fail:
29936 return NULL;
29937 }
29938
29939
29940 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29941 PyObject *resultobj;
29942 wxClipboard *arg1 = (wxClipboard *) 0 ;
29943 wxDataObject *arg2 = (wxDataObject *) 0 ;
29944 bool result;
29945 PyObject * obj0 = 0 ;
29946 PyObject * obj1 = 0 ;
29947 char *kwnames[] = {
29948 (char *) "self",(char *) "data", NULL
29949 };
29950
29951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29953 if (SWIG_arg_fail(1)) SWIG_fail;
29954 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29955 if (SWIG_arg_fail(2)) SWIG_fail;
29956 {
29957 PyThreadState* __tstate = wxPyBeginAllowThreads();
29958 result = (bool)(arg1)->SetData(arg2);
29959
29960 wxPyEndAllowThreads(__tstate);
29961 if (PyErr_Occurred()) SWIG_fail;
29962 }
29963 {
29964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29965 }
29966 return resultobj;
29967 fail:
29968 return NULL;
29969 }
29970
29971
29972 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29973 PyObject *resultobj;
29974 wxClipboard *arg1 = (wxClipboard *) 0 ;
29975 wxDataFormat *arg2 = 0 ;
29976 bool result;
29977 PyObject * obj0 = 0 ;
29978 PyObject * obj1 = 0 ;
29979 char *kwnames[] = {
29980 (char *) "self",(char *) "format", NULL
29981 };
29982
29983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29985 if (SWIG_arg_fail(1)) SWIG_fail;
29986 {
29987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29988 if (SWIG_arg_fail(2)) SWIG_fail;
29989 if (arg2 == NULL) {
29990 SWIG_null_ref("wxDataFormat");
29991 }
29992 if (SWIG_arg_fail(2)) SWIG_fail;
29993 }
29994 {
29995 PyThreadState* __tstate = wxPyBeginAllowThreads();
29996 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29997
29998 wxPyEndAllowThreads(__tstate);
29999 if (PyErr_Occurred()) SWIG_fail;
30000 }
30001 {
30002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30003 }
30004 return resultobj;
30005 fail:
30006 return NULL;
30007 }
30008
30009
30010 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30011 PyObject *resultobj;
30012 wxClipboard *arg1 = (wxClipboard *) 0 ;
30013 wxDataObject *arg2 = 0 ;
30014 bool result;
30015 PyObject * obj0 = 0 ;
30016 PyObject * obj1 = 0 ;
30017 char *kwnames[] = {
30018 (char *) "self",(char *) "data", NULL
30019 };
30020
30021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30023 if (SWIG_arg_fail(1)) SWIG_fail;
30024 {
30025 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30026 if (SWIG_arg_fail(2)) SWIG_fail;
30027 if (arg2 == NULL) {
30028 SWIG_null_ref("wxDataObject");
30029 }
30030 if (SWIG_arg_fail(2)) SWIG_fail;
30031 }
30032 {
30033 PyThreadState* __tstate = wxPyBeginAllowThreads();
30034 result = (bool)(arg1)->GetData(*arg2);
30035
30036 wxPyEndAllowThreads(__tstate);
30037 if (PyErr_Occurred()) SWIG_fail;
30038 }
30039 {
30040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30041 }
30042 return resultobj;
30043 fail:
30044 return NULL;
30045 }
30046
30047
30048 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30049 PyObject *resultobj;
30050 wxClipboard *arg1 = (wxClipboard *) 0 ;
30051 PyObject * obj0 = 0 ;
30052 char *kwnames[] = {
30053 (char *) "self", NULL
30054 };
30055
30056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30058 if (SWIG_arg_fail(1)) SWIG_fail;
30059 {
30060 PyThreadState* __tstate = wxPyBeginAllowThreads();
30061 (arg1)->Clear();
30062
30063 wxPyEndAllowThreads(__tstate);
30064 if (PyErr_Occurred()) SWIG_fail;
30065 }
30066 Py_INCREF(Py_None); resultobj = Py_None;
30067 return resultobj;
30068 fail:
30069 return NULL;
30070 }
30071
30072
30073 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30074 PyObject *resultobj;
30075 wxClipboard *arg1 = (wxClipboard *) 0 ;
30076 bool result;
30077 PyObject * obj0 = 0 ;
30078 char *kwnames[] = {
30079 (char *) "self", NULL
30080 };
30081
30082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30084 if (SWIG_arg_fail(1)) SWIG_fail;
30085 {
30086 PyThreadState* __tstate = wxPyBeginAllowThreads();
30087 result = (bool)(arg1)->Flush();
30088
30089 wxPyEndAllowThreads(__tstate);
30090 if (PyErr_Occurred()) SWIG_fail;
30091 }
30092 {
30093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30094 }
30095 return resultobj;
30096 fail:
30097 return NULL;
30098 }
30099
30100
30101 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30102 PyObject *resultobj;
30103 wxClipboard *arg1 = (wxClipboard *) 0 ;
30104 bool arg2 = (bool) true ;
30105 PyObject * obj0 = 0 ;
30106 PyObject * obj1 = 0 ;
30107 char *kwnames[] = {
30108 (char *) "self",(char *) "primary", NULL
30109 };
30110
30111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30113 if (SWIG_arg_fail(1)) SWIG_fail;
30114 if (obj1) {
30115 {
30116 arg2 = (bool)(SWIG_As_bool(obj1));
30117 if (SWIG_arg_fail(2)) SWIG_fail;
30118 }
30119 }
30120 {
30121 PyThreadState* __tstate = wxPyBeginAllowThreads();
30122 (arg1)->UsePrimarySelection(arg2);
30123
30124 wxPyEndAllowThreads(__tstate);
30125 if (PyErr_Occurred()) SWIG_fail;
30126 }
30127 Py_INCREF(Py_None); resultobj = Py_None;
30128 return resultobj;
30129 fail:
30130 return NULL;
30131 }
30132
30133
30134 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30135 PyObject *resultobj;
30136 wxClipboard *result;
30137 char *kwnames[] = {
30138 NULL
30139 };
30140
30141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30142 {
30143 PyThreadState* __tstate = wxPyBeginAllowThreads();
30144 result = (wxClipboard *)wxClipboard::Get();
30145
30146 wxPyEndAllowThreads(__tstate);
30147 if (PyErr_Occurred()) SWIG_fail;
30148 }
30149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30150 return resultobj;
30151 fail:
30152 return NULL;
30153 }
30154
30155
30156 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30157 PyObject *obj;
30158 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30159 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30160 Py_INCREF(obj);
30161 return Py_BuildValue((char *)"");
30162 }
30163 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30164 PyObject *resultobj;
30165 wxClipboard *arg1 = (wxClipboard *) NULL ;
30166 wxClipboardLocker *result;
30167 PyObject * obj0 = 0 ;
30168 char *kwnames[] = {
30169 (char *) "clipboard", NULL
30170 };
30171
30172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30173 if (obj0) {
30174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30175 if (SWIG_arg_fail(1)) SWIG_fail;
30176 }
30177 {
30178 PyThreadState* __tstate = wxPyBeginAllowThreads();
30179 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30180
30181 wxPyEndAllowThreads(__tstate);
30182 if (PyErr_Occurred()) SWIG_fail;
30183 }
30184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30192 PyObject *resultobj;
30193 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30194 PyObject * obj0 = 0 ;
30195 char *kwnames[] = {
30196 (char *) "self", NULL
30197 };
30198
30199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30201 if (SWIG_arg_fail(1)) SWIG_fail;
30202 {
30203 PyThreadState* __tstate = wxPyBeginAllowThreads();
30204 delete arg1;
30205
30206 wxPyEndAllowThreads(__tstate);
30207 if (PyErr_Occurred()) SWIG_fail;
30208 }
30209 Py_INCREF(Py_None); resultobj = Py_None;
30210 return resultobj;
30211 fail:
30212 return NULL;
30213 }
30214
30215
30216 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30217 PyObject *resultobj;
30218 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30219 bool result;
30220 PyObject * obj0 = 0 ;
30221 char *kwnames[] = {
30222 (char *) "self", NULL
30223 };
30224
30225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30227 if (SWIG_arg_fail(1)) SWIG_fail;
30228 {
30229 PyThreadState* __tstate = wxPyBeginAllowThreads();
30230 result = (bool)wxClipboardLocker___nonzero__(arg1);
30231
30232 wxPyEndAllowThreads(__tstate);
30233 if (PyErr_Occurred()) SWIG_fail;
30234 }
30235 {
30236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30237 }
30238 return resultobj;
30239 fail:
30240 return NULL;
30241 }
30242
30243
30244 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30245 PyObject *obj;
30246 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30247 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30248 Py_INCREF(obj);
30249 return Py_BuildValue((char *)"");
30250 }
30251 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30252 PyObject *resultobj;
30253 int arg1 = (int) 0 ;
30254 int arg2 = (int) 0 ;
30255 int arg3 = (int) 0 ;
30256 int arg4 = (int) 0 ;
30257 wxVideoMode *result;
30258 PyObject * obj0 = 0 ;
30259 PyObject * obj1 = 0 ;
30260 PyObject * obj2 = 0 ;
30261 PyObject * obj3 = 0 ;
30262 char *kwnames[] = {
30263 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30264 };
30265
30266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30267 if (obj0) {
30268 {
30269 arg1 = (int)(SWIG_As_int(obj0));
30270 if (SWIG_arg_fail(1)) SWIG_fail;
30271 }
30272 }
30273 if (obj1) {
30274 {
30275 arg2 = (int)(SWIG_As_int(obj1));
30276 if (SWIG_arg_fail(2)) SWIG_fail;
30277 }
30278 }
30279 if (obj2) {
30280 {
30281 arg3 = (int)(SWIG_As_int(obj2));
30282 if (SWIG_arg_fail(3)) SWIG_fail;
30283 }
30284 }
30285 if (obj3) {
30286 {
30287 arg4 = (int)(SWIG_As_int(obj3));
30288 if (SWIG_arg_fail(4)) SWIG_fail;
30289 }
30290 }
30291 {
30292 PyThreadState* __tstate = wxPyBeginAllowThreads();
30293 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30294
30295 wxPyEndAllowThreads(__tstate);
30296 if (PyErr_Occurred()) SWIG_fail;
30297 }
30298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30299 return resultobj;
30300 fail:
30301 return NULL;
30302 }
30303
30304
30305 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30306 PyObject *resultobj;
30307 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30308 PyObject * obj0 = 0 ;
30309 char *kwnames[] = {
30310 (char *) "self", NULL
30311 };
30312
30313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30315 if (SWIG_arg_fail(1)) SWIG_fail;
30316 {
30317 PyThreadState* __tstate = wxPyBeginAllowThreads();
30318 delete arg1;
30319
30320 wxPyEndAllowThreads(__tstate);
30321 if (PyErr_Occurred()) SWIG_fail;
30322 }
30323 Py_INCREF(Py_None); resultobj = Py_None;
30324 return resultobj;
30325 fail:
30326 return NULL;
30327 }
30328
30329
30330 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30331 PyObject *resultobj;
30332 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30333 wxVideoMode *arg2 = 0 ;
30334 bool result;
30335 PyObject * obj0 = 0 ;
30336 PyObject * obj1 = 0 ;
30337 char *kwnames[] = {
30338 (char *) "self",(char *) "other", NULL
30339 };
30340
30341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30343 if (SWIG_arg_fail(1)) SWIG_fail;
30344 {
30345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30346 if (SWIG_arg_fail(2)) SWIG_fail;
30347 if (arg2 == NULL) {
30348 SWIG_null_ref("wxVideoMode");
30349 }
30350 if (SWIG_arg_fail(2)) SWIG_fail;
30351 }
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30355
30356 wxPyEndAllowThreads(__tstate);
30357 if (PyErr_Occurred()) SWIG_fail;
30358 }
30359 {
30360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30361 }
30362 return resultobj;
30363 fail:
30364 return NULL;
30365 }
30366
30367
30368 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30369 PyObject *resultobj;
30370 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30371 int result;
30372 PyObject * obj0 = 0 ;
30373 char *kwnames[] = {
30374 (char *) "self", NULL
30375 };
30376
30377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30379 if (SWIG_arg_fail(1)) SWIG_fail;
30380 {
30381 PyThreadState* __tstate = wxPyBeginAllowThreads();
30382 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30383
30384 wxPyEndAllowThreads(__tstate);
30385 if (PyErr_Occurred()) SWIG_fail;
30386 }
30387 {
30388 resultobj = SWIG_From_int((int)(result));
30389 }
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30397 PyObject *resultobj;
30398 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30399 int result;
30400 PyObject * obj0 = 0 ;
30401 char *kwnames[] = {
30402 (char *) "self", NULL
30403 };
30404
30405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30407 if (SWIG_arg_fail(1)) SWIG_fail;
30408 {
30409 PyThreadState* __tstate = wxPyBeginAllowThreads();
30410 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30411
30412 wxPyEndAllowThreads(__tstate);
30413 if (PyErr_Occurred()) SWIG_fail;
30414 }
30415 {
30416 resultobj = SWIG_From_int((int)(result));
30417 }
30418 return resultobj;
30419 fail:
30420 return NULL;
30421 }
30422
30423
30424 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30425 PyObject *resultobj;
30426 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30427 int result;
30428 PyObject * obj0 = 0 ;
30429 char *kwnames[] = {
30430 (char *) "self", NULL
30431 };
30432
30433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30435 if (SWIG_arg_fail(1)) SWIG_fail;
30436 {
30437 PyThreadState* __tstate = wxPyBeginAllowThreads();
30438 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30439
30440 wxPyEndAllowThreads(__tstate);
30441 if (PyErr_Occurred()) SWIG_fail;
30442 }
30443 {
30444 resultobj = SWIG_From_int((int)(result));
30445 }
30446 return resultobj;
30447 fail:
30448 return NULL;
30449 }
30450
30451
30452 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30453 PyObject *resultobj;
30454 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30455 bool result;
30456 PyObject * obj0 = 0 ;
30457 char *kwnames[] = {
30458 (char *) "self", NULL
30459 };
30460
30461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30463 if (SWIG_arg_fail(1)) SWIG_fail;
30464 {
30465 PyThreadState* __tstate = wxPyBeginAllowThreads();
30466 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30467
30468 wxPyEndAllowThreads(__tstate);
30469 if (PyErr_Occurred()) SWIG_fail;
30470 }
30471 {
30472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30473 }
30474 return resultobj;
30475 fail:
30476 return NULL;
30477 }
30478
30479
30480 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30481 PyObject *resultobj;
30482 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30483 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30484 bool result;
30485 PyObject * obj0 = 0 ;
30486 PyObject * obj1 = 0 ;
30487 char *kwnames[] = {
30488 (char *) "self",(char *) "other", NULL
30489 };
30490
30491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30493 if (SWIG_arg_fail(1)) SWIG_fail;
30494 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30495 if (SWIG_arg_fail(2)) SWIG_fail;
30496 {
30497 PyThreadState* __tstate = wxPyBeginAllowThreads();
30498 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30499
30500 wxPyEndAllowThreads(__tstate);
30501 if (PyErr_Occurred()) SWIG_fail;
30502 }
30503 {
30504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30505 }
30506 return resultobj;
30507 fail:
30508 return NULL;
30509 }
30510
30511
30512 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30513 PyObject *resultobj;
30514 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30515 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30516 bool result;
30517 PyObject * obj0 = 0 ;
30518 PyObject * obj1 = 0 ;
30519 char *kwnames[] = {
30520 (char *) "self",(char *) "other", NULL
30521 };
30522
30523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30525 if (SWIG_arg_fail(1)) SWIG_fail;
30526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30527 if (SWIG_arg_fail(2)) SWIG_fail;
30528 {
30529 PyThreadState* __tstate = wxPyBeginAllowThreads();
30530 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30531
30532 wxPyEndAllowThreads(__tstate);
30533 if (PyErr_Occurred()) SWIG_fail;
30534 }
30535 {
30536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30537 }
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30545 PyObject *resultobj;
30546 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30547 int arg2 ;
30548 PyObject * obj0 = 0 ;
30549 PyObject * obj1 = 0 ;
30550 char *kwnames[] = {
30551 (char *) "self",(char *) "w", NULL
30552 };
30553
30554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30556 if (SWIG_arg_fail(1)) SWIG_fail;
30557 {
30558 arg2 = (int)(SWIG_As_int(obj1));
30559 if (SWIG_arg_fail(2)) SWIG_fail;
30560 }
30561 if (arg1) (arg1)->w = arg2;
30562
30563 Py_INCREF(Py_None); resultobj = Py_None;
30564 return resultobj;
30565 fail:
30566 return NULL;
30567 }
30568
30569
30570 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30571 PyObject *resultobj;
30572 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30573 int result;
30574 PyObject * obj0 = 0 ;
30575 char *kwnames[] = {
30576 (char *) "self", NULL
30577 };
30578
30579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30581 if (SWIG_arg_fail(1)) SWIG_fail;
30582 result = (int) ((arg1)->w);
30583
30584 {
30585 resultobj = SWIG_From_int((int)(result));
30586 }
30587 return resultobj;
30588 fail:
30589 return NULL;
30590 }
30591
30592
30593 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30594 PyObject *resultobj;
30595 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30596 int arg2 ;
30597 PyObject * obj0 = 0 ;
30598 PyObject * obj1 = 0 ;
30599 char *kwnames[] = {
30600 (char *) "self",(char *) "h", NULL
30601 };
30602
30603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30605 if (SWIG_arg_fail(1)) SWIG_fail;
30606 {
30607 arg2 = (int)(SWIG_As_int(obj1));
30608 if (SWIG_arg_fail(2)) SWIG_fail;
30609 }
30610 if (arg1) (arg1)->h = arg2;
30611
30612 Py_INCREF(Py_None); resultobj = Py_None;
30613 return resultobj;
30614 fail:
30615 return NULL;
30616 }
30617
30618
30619 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30620 PyObject *resultobj;
30621 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30622 int result;
30623 PyObject * obj0 = 0 ;
30624 char *kwnames[] = {
30625 (char *) "self", NULL
30626 };
30627
30628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30630 if (SWIG_arg_fail(1)) SWIG_fail;
30631 result = (int) ((arg1)->h);
30632
30633 {
30634 resultobj = SWIG_From_int((int)(result));
30635 }
30636 return resultobj;
30637 fail:
30638 return NULL;
30639 }
30640
30641
30642 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30643 PyObject *resultobj;
30644 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30645 int arg2 ;
30646 PyObject * obj0 = 0 ;
30647 PyObject * obj1 = 0 ;
30648 char *kwnames[] = {
30649 (char *) "self",(char *) "bpp", NULL
30650 };
30651
30652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30654 if (SWIG_arg_fail(1)) SWIG_fail;
30655 {
30656 arg2 = (int)(SWIG_As_int(obj1));
30657 if (SWIG_arg_fail(2)) SWIG_fail;
30658 }
30659 if (arg1) (arg1)->bpp = arg2;
30660
30661 Py_INCREF(Py_None); resultobj = Py_None;
30662 return resultobj;
30663 fail:
30664 return NULL;
30665 }
30666
30667
30668 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30669 PyObject *resultobj;
30670 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30671 int result;
30672 PyObject * obj0 = 0 ;
30673 char *kwnames[] = {
30674 (char *) "self", NULL
30675 };
30676
30677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30679 if (SWIG_arg_fail(1)) SWIG_fail;
30680 result = (int) ((arg1)->bpp);
30681
30682 {
30683 resultobj = SWIG_From_int((int)(result));
30684 }
30685 return resultobj;
30686 fail:
30687 return NULL;
30688 }
30689
30690
30691 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30692 PyObject *resultobj;
30693 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30694 int arg2 ;
30695 PyObject * obj0 = 0 ;
30696 PyObject * obj1 = 0 ;
30697 char *kwnames[] = {
30698 (char *) "self",(char *) "refresh", NULL
30699 };
30700
30701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30703 if (SWIG_arg_fail(1)) SWIG_fail;
30704 {
30705 arg2 = (int)(SWIG_As_int(obj1));
30706 if (SWIG_arg_fail(2)) SWIG_fail;
30707 }
30708 if (arg1) (arg1)->refresh = arg2;
30709
30710 Py_INCREF(Py_None); resultobj = Py_None;
30711 return resultobj;
30712 fail:
30713 return NULL;
30714 }
30715
30716
30717 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30718 PyObject *resultobj;
30719 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30720 int result;
30721 PyObject * obj0 = 0 ;
30722 char *kwnames[] = {
30723 (char *) "self", NULL
30724 };
30725
30726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30728 if (SWIG_arg_fail(1)) SWIG_fail;
30729 result = (int) ((arg1)->refresh);
30730
30731 {
30732 resultobj = SWIG_From_int((int)(result));
30733 }
30734 return resultobj;
30735 fail:
30736 return NULL;
30737 }
30738
30739
30740 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30741 PyObject *obj;
30742 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30743 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30744 Py_INCREF(obj);
30745 return Py_BuildValue((char *)"");
30746 }
30747 static int _wrap_DefaultVideoMode_set(PyObject *) {
30748 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30749 return 1;
30750 }
30751
30752
30753 static PyObject *_wrap_DefaultVideoMode_get(void) {
30754 PyObject *pyobj;
30755
30756 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30757 return pyobj;
30758 }
30759
30760
30761 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30762 PyObject *resultobj;
30763 size_t arg1 = (size_t) 0 ;
30764 wxDisplay *result;
30765 PyObject * obj0 = 0 ;
30766 char *kwnames[] = {
30767 (char *) "index", NULL
30768 };
30769
30770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30771 if (obj0) {
30772 {
30773 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30774 if (SWIG_arg_fail(1)) SWIG_fail;
30775 }
30776 }
30777 {
30778 PyThreadState* __tstate = wxPyBeginAllowThreads();
30779 result = (wxDisplay *)new wxDisplay(arg1);
30780
30781 wxPyEndAllowThreads(__tstate);
30782 if (PyErr_Occurred()) SWIG_fail;
30783 }
30784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30785 return resultobj;
30786 fail:
30787 return NULL;
30788 }
30789
30790
30791 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30792 PyObject *resultobj;
30793 wxDisplay *arg1 = (wxDisplay *) 0 ;
30794 PyObject * obj0 = 0 ;
30795 char *kwnames[] = {
30796 (char *) "self", NULL
30797 };
30798
30799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30801 if (SWIG_arg_fail(1)) SWIG_fail;
30802 {
30803 PyThreadState* __tstate = wxPyBeginAllowThreads();
30804 delete arg1;
30805
30806 wxPyEndAllowThreads(__tstate);
30807 if (PyErr_Occurred()) SWIG_fail;
30808 }
30809 Py_INCREF(Py_None); resultobj = Py_None;
30810 return resultobj;
30811 fail:
30812 return NULL;
30813 }
30814
30815
30816 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30817 PyObject *resultobj;
30818 size_t result;
30819 char *kwnames[] = {
30820 NULL
30821 };
30822
30823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30824 {
30825 PyThreadState* __tstate = wxPyBeginAllowThreads();
30826 result = (size_t)wxDisplay::GetCount();
30827
30828 wxPyEndAllowThreads(__tstate);
30829 if (PyErr_Occurred()) SWIG_fail;
30830 }
30831 {
30832 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30833 }
30834 return resultobj;
30835 fail:
30836 return NULL;
30837 }
30838
30839
30840 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30841 PyObject *resultobj;
30842 wxPoint *arg1 = 0 ;
30843 int result;
30844 wxPoint temp1 ;
30845 PyObject * obj0 = 0 ;
30846 char *kwnames[] = {
30847 (char *) "pt", NULL
30848 };
30849
30850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30851 {
30852 arg1 = &temp1;
30853 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30854 }
30855 {
30856 PyThreadState* __tstate = wxPyBeginAllowThreads();
30857 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30858
30859 wxPyEndAllowThreads(__tstate);
30860 if (PyErr_Occurred()) SWIG_fail;
30861 }
30862 {
30863 resultobj = SWIG_From_int((int)(result));
30864 }
30865 return resultobj;
30866 fail:
30867 return NULL;
30868 }
30869
30870
30871 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30872 PyObject *resultobj;
30873 wxWindow *arg1 = (wxWindow *) 0 ;
30874 int result;
30875 PyObject * obj0 = 0 ;
30876 char *kwnames[] = {
30877 (char *) "window", NULL
30878 };
30879
30880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30882 if (SWIG_arg_fail(1)) SWIG_fail;
30883 {
30884 PyThreadState* __tstate = wxPyBeginAllowThreads();
30885 result = (int)Display_GetFromWindow(arg1);
30886
30887 wxPyEndAllowThreads(__tstate);
30888 if (PyErr_Occurred()) SWIG_fail;
30889 }
30890 {
30891 resultobj = SWIG_From_int((int)(result));
30892 }
30893 return resultobj;
30894 fail:
30895 return NULL;
30896 }
30897
30898
30899 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30900 PyObject *resultobj;
30901 wxDisplay *arg1 = (wxDisplay *) 0 ;
30902 bool result;
30903 PyObject * obj0 = 0 ;
30904 char *kwnames[] = {
30905 (char *) "self", NULL
30906 };
30907
30908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30910 if (SWIG_arg_fail(1)) SWIG_fail;
30911 {
30912 PyThreadState* __tstate = wxPyBeginAllowThreads();
30913 result = (bool)((wxDisplay const *)arg1)->IsOk();
30914
30915 wxPyEndAllowThreads(__tstate);
30916 if (PyErr_Occurred()) SWIG_fail;
30917 }
30918 {
30919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30920 }
30921 return resultobj;
30922 fail:
30923 return NULL;
30924 }
30925
30926
30927 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30928 PyObject *resultobj;
30929 wxDisplay *arg1 = (wxDisplay *) 0 ;
30930 wxRect result;
30931 PyObject * obj0 = 0 ;
30932 char *kwnames[] = {
30933 (char *) "self", NULL
30934 };
30935
30936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30938 if (SWIG_arg_fail(1)) SWIG_fail;
30939 {
30940 PyThreadState* __tstate = wxPyBeginAllowThreads();
30941 result = ((wxDisplay const *)arg1)->GetGeometry();
30942
30943 wxPyEndAllowThreads(__tstate);
30944 if (PyErr_Occurred()) SWIG_fail;
30945 }
30946 {
30947 wxRect * resultptr;
30948 resultptr = new wxRect((wxRect &)(result));
30949 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30950 }
30951 return resultobj;
30952 fail:
30953 return NULL;
30954 }
30955
30956
30957 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30958 PyObject *resultobj;
30959 wxDisplay *arg1 = (wxDisplay *) 0 ;
30960 wxString result;
30961 PyObject * obj0 = 0 ;
30962 char *kwnames[] = {
30963 (char *) "self", NULL
30964 };
30965
30966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30968 if (SWIG_arg_fail(1)) SWIG_fail;
30969 {
30970 PyThreadState* __tstate = wxPyBeginAllowThreads();
30971 result = ((wxDisplay const *)arg1)->GetName();
30972
30973 wxPyEndAllowThreads(__tstate);
30974 if (PyErr_Occurred()) SWIG_fail;
30975 }
30976 {
30977 #if wxUSE_UNICODE
30978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30979 #else
30980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30981 #endif
30982 }
30983 return resultobj;
30984 fail:
30985 return NULL;
30986 }
30987
30988
30989 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30990 PyObject *resultobj;
30991 wxDisplay *arg1 = (wxDisplay *) 0 ;
30992 bool result;
30993 PyObject * obj0 = 0 ;
30994 char *kwnames[] = {
30995 (char *) "self", NULL
30996 };
30997
30998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31000 if (SWIG_arg_fail(1)) SWIG_fail;
31001 {
31002 PyThreadState* __tstate = wxPyBeginAllowThreads();
31003 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31004
31005 wxPyEndAllowThreads(__tstate);
31006 if (PyErr_Occurred()) SWIG_fail;
31007 }
31008 {
31009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31010 }
31011 return resultobj;
31012 fail:
31013 return NULL;
31014 }
31015
31016
31017 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31018 PyObject *resultobj;
31019 wxDisplay *arg1 = (wxDisplay *) 0 ;
31020 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31021 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31022 PyObject *result;
31023 PyObject * obj0 = 0 ;
31024 PyObject * obj1 = 0 ;
31025 char *kwnames[] = {
31026 (char *) "self",(char *) "mode", NULL
31027 };
31028
31029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31031 if (SWIG_arg_fail(1)) SWIG_fail;
31032 if (obj1) {
31033 {
31034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31035 if (SWIG_arg_fail(2)) SWIG_fail;
31036 if (arg2 == NULL) {
31037 SWIG_null_ref("wxVideoMode");
31038 }
31039 if (SWIG_arg_fail(2)) SWIG_fail;
31040 }
31041 }
31042 {
31043 PyThreadState* __tstate = wxPyBeginAllowThreads();
31044 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31045
31046 wxPyEndAllowThreads(__tstate);
31047 if (PyErr_Occurred()) SWIG_fail;
31048 }
31049 resultobj = result;
31050 return resultobj;
31051 fail:
31052 return NULL;
31053 }
31054
31055
31056 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31057 PyObject *resultobj;
31058 wxDisplay *arg1 = (wxDisplay *) 0 ;
31059 wxVideoMode result;
31060 PyObject * obj0 = 0 ;
31061 char *kwnames[] = {
31062 (char *) "self", NULL
31063 };
31064
31065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31067 if (SWIG_arg_fail(1)) SWIG_fail;
31068 {
31069 PyThreadState* __tstate = wxPyBeginAllowThreads();
31070 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31071
31072 wxPyEndAllowThreads(__tstate);
31073 if (PyErr_Occurred()) SWIG_fail;
31074 }
31075 {
31076 wxVideoMode * resultptr;
31077 resultptr = new wxVideoMode((wxVideoMode &)(result));
31078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31079 }
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31087 PyObject *resultobj;
31088 wxDisplay *arg1 = (wxDisplay *) 0 ;
31089 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31090 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31091 bool result;
31092 PyObject * obj0 = 0 ;
31093 PyObject * obj1 = 0 ;
31094 char *kwnames[] = {
31095 (char *) "self",(char *) "mode", NULL
31096 };
31097
31098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31100 if (SWIG_arg_fail(1)) SWIG_fail;
31101 if (obj1) {
31102 {
31103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31104 if (SWIG_arg_fail(2)) SWIG_fail;
31105 if (arg2 == NULL) {
31106 SWIG_null_ref("wxVideoMode");
31107 }
31108 if (SWIG_arg_fail(2)) SWIG_fail;
31109 }
31110 }
31111 {
31112 PyThreadState* __tstate = wxPyBeginAllowThreads();
31113 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31114
31115 wxPyEndAllowThreads(__tstate);
31116 if (PyErr_Occurred()) SWIG_fail;
31117 }
31118 {
31119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31120 }
31121 return resultobj;
31122 fail:
31123 return NULL;
31124 }
31125
31126
31127 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31128 PyObject *resultobj;
31129 wxDisplay *arg1 = (wxDisplay *) 0 ;
31130 PyObject * obj0 = 0 ;
31131 char *kwnames[] = {
31132 (char *) "self", NULL
31133 };
31134
31135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31137 if (SWIG_arg_fail(1)) SWIG_fail;
31138 {
31139 PyThreadState* __tstate = wxPyBeginAllowThreads();
31140 (arg1)->ResetMode();
31141
31142 wxPyEndAllowThreads(__tstate);
31143 if (PyErr_Occurred()) SWIG_fail;
31144 }
31145 Py_INCREF(Py_None); resultobj = Py_None;
31146 return resultobj;
31147 fail:
31148 return NULL;
31149 }
31150
31151
31152 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31153 PyObject *obj;
31154 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31155 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31156 Py_INCREF(obj);
31157 return Py_BuildValue((char *)"");
31158 }
31159 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31160 PyObject *resultobj;
31161 wxStandardPaths *result;
31162 char *kwnames[] = {
31163 NULL
31164 };
31165
31166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 result = (wxStandardPaths *)StandardPaths_Get();
31170
31171 wxPyEndAllowThreads(__tstate);
31172 if (PyErr_Occurred()) SWIG_fail;
31173 }
31174 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31175 return resultobj;
31176 fail:
31177 return NULL;
31178 }
31179
31180
31181 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31182 PyObject *resultobj;
31183 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31184 wxString result;
31185 PyObject * obj0 = 0 ;
31186 char *kwnames[] = {
31187 (char *) "self", NULL
31188 };
31189
31190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31192 if (SWIG_arg_fail(1)) SWIG_fail;
31193 {
31194 PyThreadState* __tstate = wxPyBeginAllowThreads();
31195 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31196
31197 wxPyEndAllowThreads(__tstate);
31198 if (PyErr_Occurred()) SWIG_fail;
31199 }
31200 {
31201 #if wxUSE_UNICODE
31202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31203 #else
31204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31205 #endif
31206 }
31207 return resultobj;
31208 fail:
31209 return NULL;
31210 }
31211
31212
31213 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31214 PyObject *resultobj;
31215 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31216 wxString result;
31217 PyObject * obj0 = 0 ;
31218 char *kwnames[] = {
31219 (char *) "self", NULL
31220 };
31221
31222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31224 if (SWIG_arg_fail(1)) SWIG_fail;
31225 {
31226 PyThreadState* __tstate = wxPyBeginAllowThreads();
31227 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31228
31229 wxPyEndAllowThreads(__tstate);
31230 if (PyErr_Occurred()) SWIG_fail;
31231 }
31232 {
31233 #if wxUSE_UNICODE
31234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31235 #else
31236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31237 #endif
31238 }
31239 return resultobj;
31240 fail:
31241 return NULL;
31242 }
31243
31244
31245 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31246 PyObject *resultobj;
31247 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31248 wxString result;
31249 PyObject * obj0 = 0 ;
31250 char *kwnames[] = {
31251 (char *) "self", NULL
31252 };
31253
31254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31256 if (SWIG_arg_fail(1)) SWIG_fail;
31257 {
31258 PyThreadState* __tstate = wxPyBeginAllowThreads();
31259 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31260
31261 wxPyEndAllowThreads(__tstate);
31262 if (PyErr_Occurred()) SWIG_fail;
31263 }
31264 {
31265 #if wxUSE_UNICODE
31266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31267 #else
31268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31269 #endif
31270 }
31271 return resultobj;
31272 fail:
31273 return NULL;
31274 }
31275
31276
31277 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31278 PyObject *resultobj;
31279 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31280 wxString result;
31281 PyObject * obj0 = 0 ;
31282 char *kwnames[] = {
31283 (char *) "self", NULL
31284 };
31285
31286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31288 if (SWIG_arg_fail(1)) SWIG_fail;
31289 {
31290 PyThreadState* __tstate = wxPyBeginAllowThreads();
31291 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31292
31293 wxPyEndAllowThreads(__tstate);
31294 if (PyErr_Occurred()) SWIG_fail;
31295 }
31296 {
31297 #if wxUSE_UNICODE
31298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31299 #else
31300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31301 #endif
31302 }
31303 return resultobj;
31304 fail:
31305 return NULL;
31306 }
31307
31308
31309 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31310 PyObject *resultobj;
31311 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31312 wxString result;
31313 PyObject * obj0 = 0 ;
31314 char *kwnames[] = {
31315 (char *) "self", NULL
31316 };
31317
31318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31320 if (SWIG_arg_fail(1)) SWIG_fail;
31321 {
31322 PyThreadState* __tstate = wxPyBeginAllowThreads();
31323 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31324
31325 wxPyEndAllowThreads(__tstate);
31326 if (PyErr_Occurred()) SWIG_fail;
31327 }
31328 {
31329 #if wxUSE_UNICODE
31330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31331 #else
31332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31333 #endif
31334 }
31335 return resultobj;
31336 fail:
31337 return NULL;
31338 }
31339
31340
31341 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31342 PyObject *resultobj;
31343 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31344 wxString result;
31345 PyObject * obj0 = 0 ;
31346 char *kwnames[] = {
31347 (char *) "self", NULL
31348 };
31349
31350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31352 if (SWIG_arg_fail(1)) SWIG_fail;
31353 {
31354 PyThreadState* __tstate = wxPyBeginAllowThreads();
31355 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31356
31357 wxPyEndAllowThreads(__tstate);
31358 if (PyErr_Occurred()) SWIG_fail;
31359 }
31360 {
31361 #if wxUSE_UNICODE
31362 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31363 #else
31364 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31365 #endif
31366 }
31367 return resultobj;
31368 fail:
31369 return NULL;
31370 }
31371
31372
31373 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31374 PyObject *resultobj;
31375 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31376 wxString result;
31377 PyObject * obj0 = 0 ;
31378 char *kwnames[] = {
31379 (char *) "self", NULL
31380 };
31381
31382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31384 if (SWIG_arg_fail(1)) SWIG_fail;
31385 {
31386 PyThreadState* __tstate = wxPyBeginAllowThreads();
31387 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31388
31389 wxPyEndAllowThreads(__tstate);
31390 if (PyErr_Occurred()) SWIG_fail;
31391 }
31392 {
31393 #if wxUSE_UNICODE
31394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31395 #else
31396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31397 #endif
31398 }
31399 return resultobj;
31400 fail:
31401 return NULL;
31402 }
31403
31404
31405 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31406 PyObject *resultobj;
31407 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31408 wxString *arg2 = 0 ;
31409 bool temp2 = false ;
31410 PyObject * obj0 = 0 ;
31411 PyObject * obj1 = 0 ;
31412 char *kwnames[] = {
31413 (char *) "self",(char *) "prefix", NULL
31414 };
31415
31416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
31421 if (arg2 == NULL) SWIG_fail;
31422 temp2 = true;
31423 }
31424 {
31425 PyThreadState* __tstate = wxPyBeginAllowThreads();
31426 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31427
31428 wxPyEndAllowThreads(__tstate);
31429 if (PyErr_Occurred()) SWIG_fail;
31430 }
31431 Py_INCREF(Py_None); resultobj = Py_None;
31432 {
31433 if (temp2)
31434 delete arg2;
31435 }
31436 return resultobj;
31437 fail:
31438 {
31439 if (temp2)
31440 delete arg2;
31441 }
31442 return NULL;
31443 }
31444
31445
31446 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31447 PyObject *resultobj;
31448 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31449 wxString result;
31450 PyObject * obj0 = 0 ;
31451 char *kwnames[] = {
31452 (char *) "self", NULL
31453 };
31454
31455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31457 if (SWIG_arg_fail(1)) SWIG_fail;
31458 {
31459 PyThreadState* __tstate = wxPyBeginAllowThreads();
31460 result = wxStandardPaths_GetInstallPrefix(arg1);
31461
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 {
31466 #if wxUSE_UNICODE
31467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31468 #else
31469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31470 #endif
31471 }
31472 return resultobj;
31473 fail:
31474 return NULL;
31475 }
31476
31477
31478 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31479 PyObject *obj;
31480 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31481 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31482 Py_INCREF(obj);
31483 return Py_BuildValue((char *)"");
31484 }
31485 static PyMethodDef SwigMethods[] = {
31486 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31493 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31501 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31565 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31573 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31591 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31594 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31597 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31600 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31606 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31620 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31626 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31632 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31635 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31649 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31652 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31653 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31656 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31683 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31685 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31687 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31689 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31696 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31702 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31716 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31720 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31723 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31740 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31748 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31795 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31813 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31823 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31839 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31855 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31869 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31879 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31922 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31925 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31928 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31932 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32025 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32026 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32027 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32028 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32045 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32090 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32124 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32132 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32133 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32138 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32147 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32154 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32157 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32160 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32165 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32168 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32172 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32175 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32179 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32180 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32184 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32188 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32192 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32202 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32215 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32223 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32231 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32245 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32249 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32267 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32277 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32279 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32280 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32281 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32286 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32290 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32292 { NULL, NULL, 0, NULL }
32293 };
32294
32295
32296 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32297
32298 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32299 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32300 }
32301 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32302 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32303 }
32304 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32305 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32306 }
32307 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32308 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32309 }
32310 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32311 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32312 }
32313 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32314 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32315 }
32316 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32317 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32318 }
32319 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32320 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32321 }
32322 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32323 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32324 }
32325 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32326 return (void *)((wxEvent *) ((wxPyEvent *) x));
32327 }
32328 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32329 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32330 }
32331 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32332 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32333 }
32334 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32335 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32336 }
32337 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32338 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32339 }
32340 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32341 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32342 }
32343 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32344 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32345 }
32346 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32347 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32348 }
32349 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32350 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32351 }
32352 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32353 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32354 }
32355 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32356 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32357 }
32358 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32359 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32360 }
32361 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32362 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32363 }
32364 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32365 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32366 }
32367 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32368 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32369 }
32370 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32371 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32372 }
32373 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32374 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32375 }
32376 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32377 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32378 }
32379 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32380 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32381 }
32382 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32383 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32384 }
32385 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32386 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32387 }
32388 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32389 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32390 }
32391 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32392 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32393 }
32394 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32395 return (void *)((wxEvent *) ((wxShowEvent *) x));
32396 }
32397 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32398 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32399 }
32400 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32401 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32402 }
32403 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32404 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32405 }
32406 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32407 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32408 }
32409 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32410 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32411 }
32412 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32413 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32414 }
32415 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32416 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32417 }
32418 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32419 return (void *)((wxConfigBase *) ((wxConfig *) x));
32420 }
32421 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32422 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32423 }
32424 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32425 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32426 }
32427 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32428 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32429 }
32430 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32431 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32432 }
32433 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32434 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32435 }
32436 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32437 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32438 }
32439 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32440 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32441 }
32442 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32443 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32444 }
32445 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32446 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32447 }
32448 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32449 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32450 }
32451 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32452 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32453 }
32454 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32455 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32456 }
32457 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32458 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32459 }
32460 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32461 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32462 }
32463 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32464 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32465 }
32466 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32467 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32468 }
32469 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32470 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32471 }
32472 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32473 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32474 }
32475 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32476 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32477 }
32478 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32479 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32480 }
32481 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32482 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32483 }
32484 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32485 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32486 }
32487 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32488 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32489 }
32490 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32491 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32492 }
32493 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32494 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32495 }
32496 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32497 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32498 }
32499 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32500 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32501 }
32502 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32503 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32504 }
32505 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32506 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32507 }
32508 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32509 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32510 }
32511 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32512 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32513 }
32514 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32515 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32516 }
32517 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32518 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32519 }
32520 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32521 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32522 }
32523 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32524 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32525 }
32526 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32527 return (void *)((wxObject *) ((wxSizerItem *) x));
32528 }
32529 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32530 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32531 }
32532 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32533 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32534 }
32535 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32536 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32537 }
32538 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32539 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32540 }
32541 static void *_p_wxSizerTo_p_wxObject(void *x) {
32542 return (void *)((wxObject *) ((wxSizer *) x));
32543 }
32544 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32545 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32546 }
32547 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32548 return (void *)((wxObject *) ((wxFileHistory *) x));
32549 }
32550 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32551 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32552 }
32553 static void *_p_wxEventTo_p_wxObject(void *x) {
32554 return (void *)((wxObject *) ((wxEvent *) x));
32555 }
32556 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32557 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32558 }
32559 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32560 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32561 }
32562 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32563 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32564 }
32565 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32566 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32567 }
32568 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32569 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32570 }
32571 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32572 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32573 }
32574 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32575 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32576 }
32577 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32578 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32579 }
32580 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32581 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32582 }
32583 static void *_p_wxControlTo_p_wxObject(void *x) {
32584 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32585 }
32586 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32587 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32588 }
32589 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32590 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32591 }
32592 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32593 return (void *)((wxObject *) ((wxFSFile *) x));
32594 }
32595 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32596 return (void *)((wxObject *) ((wxClipboard *) x));
32597 }
32598 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32599 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32600 }
32601 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32602 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32603 }
32604 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32605 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32606 }
32607 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32608 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32609 }
32610 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32611 return (void *)((wxObject *) ((wxToolTip *) x));
32612 }
32613 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32614 return (void *)((wxObject *) ((wxMenuItem *) x));
32615 }
32616 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32617 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32618 }
32619 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32620 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32621 }
32622 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32623 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32624 }
32625 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32626 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32627 }
32628 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32629 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32630 }
32631 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32632 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32633 }
32634 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32635 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32636 }
32637 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32638 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32639 }
32640 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32641 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32642 }
32643 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32644 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32645 }
32646 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32647 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32648 }
32649 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32650 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32651 }
32652 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32653 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32654 }
32655 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32656 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32657 }
32658 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32659 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32660 }
32661 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32662 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32663 }
32664 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32665 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32666 }
32667 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32668 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32669 }
32670 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32671 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32672 }
32673 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32674 return (void *)((wxObject *) ((wxImageHandler *) x));
32675 }
32676 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32677 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32678 }
32679 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32680 return (void *)((wxObject *) ((wxEvtHandler *) x));
32681 }
32682 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32683 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32684 }
32685 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32686 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32687 }
32688 static void *_p_wxImageTo_p_wxObject(void *x) {
32689 return (void *)((wxObject *) ((wxImage *) x));
32690 }
32691 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32692 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32693 }
32694 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32695 return (void *)((wxObject *) ((wxSystemOptions *) x));
32696 }
32697 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32698 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32699 }
32700 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32701 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32702 }
32703 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32704 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32705 }
32706 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32707 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32708 }
32709 static void *_p_wxWindowTo_p_wxObject(void *x) {
32710 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32711 }
32712 static void *_p_wxMenuTo_p_wxObject(void *x) {
32713 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32714 }
32715 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32716 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32717 }
32718 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32719 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32720 }
32721 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32722 return (void *)((wxObject *) ((wxFileSystem *) x));
32723 }
32724 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32725 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32726 }
32727 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32728 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32729 }
32730 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32731 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32732 }
32733 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32734 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32735 }
32736 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32737 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32738 }
32739 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32740 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32741 }
32742 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32743 return (void *)((wxObject *) ((wxBusyInfo *) x));
32744 }
32745 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32746 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32747 }
32748 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32749 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32750 }
32751 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32752 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32753 }
32754 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32755 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32756 }
32757 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32758 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32759 }
32760 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32761 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32762 }
32763 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32764 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32765 }
32766 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32767 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32768 }
32769 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32770 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32771 }
32772 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32773 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32774 }
32775 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32776 return (void *)((wxLog *) ((wxLogStderr *) x));
32777 }
32778 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32779 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32780 }
32781 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32782 return (void *)((wxLog *) ((wxLogWindow *) x));
32783 }
32784 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32785 return (void *)((wxLog *) ((wxLogChain *) x));
32786 }
32787 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32788 return (void *)((wxLog *) ((wxLogGui *) x));
32789 }
32790 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32791 return (void *)((wxLog *) ((wxPyLog *) x));
32792 }
32793 static void *_p_wxControlTo_p_wxWindow(void *x) {
32794 return (void *)((wxWindow *) ((wxControl *) x));
32795 }
32796 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32797 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32798 }
32799 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32800 return (void *)((wxWindow *) ((wxMenuBar *) x));
32801 }
32802 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32803 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32804 }
32805 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32806 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32807 }
32808 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}};
32809 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}};
32810 static swig_type_info _swigt__p_wxMetafile[] = {{"_p_wxMetafile", 0, "wxMetafile *", 0, 0, 0, 0},{"_p_wxMetafile", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32811 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}};
32812 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}};
32813 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}};
32814 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}};
32815 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}};
32816 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}};
32817 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}};
32818 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}};
32819 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}};
32820 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}};
32821 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}};
32822 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}};
32823 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}};
32824 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}};
32825 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}};
32826 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}};
32827 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}};
32828 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}};
32829 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}};
32830 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}};
32831 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}};
32832 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}};
32833 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}};
32834 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}};
32835 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}};
32836 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}};
32837 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}};
32838 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}};
32839 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}};
32840 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}};
32841 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}};
32842 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}};
32843 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}};
32844 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}};
32845 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}};
32846 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}};
32847 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}};
32848 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}};
32849 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}};
32850 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}};
32851 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}};
32852 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}};
32853 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}};
32854 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}};
32855 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}};
32856 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}};
32857 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}};
32858 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}};
32859 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}};
32860 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}};
32861 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}};
32862 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}};
32863 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}};
32864 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}};
32865 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}};
32866 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}};
32867 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}};
32868 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}};
32869 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}};
32870 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}};
32871 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}};
32872 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}};
32873 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}};
32874 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}};
32875 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}};
32876 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}};
32877 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}};
32878 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}};
32879 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}};
32880 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}};
32881 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}};
32882 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}};
32883 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}};
32884 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}};
32885 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}};
32886 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}};
32887 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}};
32888 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}};
32889 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}};
32890 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}};
32891 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}};
32892 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}};
32893 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}};
32894 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}};
32895 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}};
32896 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}};
32897 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}};
32898 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}};
32899 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}};
32900 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}};
32901 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}};
32902 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}};
32903 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}};
32904 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}};
32905
32906 static swig_type_info *swig_types_initial[] = {
32907 _swigt__p_wxLogChain,
32908 _swigt__p_wxMutexGuiLocker,
32909 _swigt__p_wxMetafile,
32910 _swigt__p_wxFileHistory,
32911 _swigt__p_wxLog,
32912 _swigt__p_wxMenu,
32913 _swigt__p_wxEvent,
32914 _swigt__p_wxDateTime__TimeZone,
32915 _swigt__p_wxConfigBase,
32916 _swigt__p_wxDisplay,
32917 _swigt__p_wxFileType,
32918 _swigt__p_wxLogGui,
32919 _swigt__p_wxFont,
32920 _swigt__p_wxDataFormat,
32921 _swigt__p_wxTimerEvent,
32922 _swigt__p_wxCaret,
32923 _swigt__ptrdiff_t,
32924 _swigt__std__ptrdiff_t,
32925 _swigt__p_int,
32926 _swigt__p_wxSize,
32927 _swigt__p_wxClipboard,
32928 _swigt__p_wxStopWatch,
32929 _swigt__p_wxDC,
32930 _swigt__p_wxClipboardLocker,
32931 _swigt__p_wxIcon,
32932 _swigt__p_wxLogStderr,
32933 _swigt__p_wxLogTextCtrl,
32934 _swigt__p_wxTextCtrl,
32935 _swigt__p_wxBusyCursor,
32936 _swigt__p_wxBitmapDataObject,
32937 _swigt__p_wxTextDataObject,
32938 _swigt__p_wxDataObject,
32939 _swigt__p_wxPyTextDataObject,
32940 _swigt__p_wxPyBitmapDataObject,
32941 _swigt__p_wxFileDataObject,
32942 _swigt__p_wxCustomDataObject,
32943 _swigt__p_wxURLDataObject,
32944 _swigt__p_wxMetafileDataObject,
32945 _swigt__p_wxSound,
32946 _swigt__p_wxTimerRunner,
32947 _swigt__p_wxLogWindow,
32948 _swigt__p_wxTimeSpan,
32949 _swigt__p_wxArrayString,
32950 _swigt__p_wxWindowDisabler,
32951 _swigt__p_form_ops_t,
32952 _swigt__p_wxToolTip,
32953 _swigt__p_wxDataObjectComposite,
32954 _swigt__p_wxSystemSettings,
32955 _swigt__p_wxFileConfig,
32956 _swigt__p_wxVideoMode,
32957 _swigt__p_wxDataObjectSimple,
32958 _swigt__p_wxPyDataObjectSimple,
32959 _swigt__p_wxDuplexMode,
32960 _swigt__p_wxEvtHandler,
32961 _swigt__p_wxRect,
32962 _swigt__p_char,
32963 _swigt__p_wxSingleInstanceChecker,
32964 _swigt__p_wxStandardPaths,
32965 _swigt__p_wxFileTypeInfo,
32966 _swigt__p_wxFrame,
32967 _swigt__p_wxTimer,
32968 _swigt__p_wxPaperSize,
32969 _swigt__p_wxMimeTypesManager,
32970 _swigt__p_wxPyArtProvider,
32971 _swigt__p_wxPyTipProvider,
32972 _swigt__p_wxTipProvider,
32973 _swigt__p_wxJoystick,
32974 _swigt__p_wxSystemOptions,
32975 _swigt__p_wxPoint,
32976 _swigt__p_wxJoystickEvent,
32977 _swigt__p_wxCursor,
32978 _swigt__p_wxObject,
32979 _swigt__p_wxOutputStream,
32980 _swigt__p_wxDateTime,
32981 _swigt__p_wxPyDropSource,
32982 _swigt__p_unsigned_long,
32983 _swigt__p_wxKillError,
32984 _swigt__p_wxWindow,
32985 _swigt__p_wxString,
32986 _swigt__p_wxPyProcess,
32987 _swigt__p_wxBitmap,
32988 _swigt__p_wxConfig,
32989 _swigt__unsigned_int,
32990 _swigt__p_unsigned_int,
32991 _swigt__p_unsigned_char,
32992 _swigt__p_wxChar,
32993 _swigt__p_wxBusyInfo,
32994 _swigt__p_wxPyDropTarget,
32995 _swigt__p_wxPyTextDropTarget,
32996 _swigt__p_wxPyFileDropTarget,
32997 _swigt__p_wxProcessEvent,
32998 _swigt__p_wxPyLog,
32999 _swigt__p_wxLogNull,
33000 _swigt__p_wxColour,
33001 _swigt__p_wxPyTimer,
33002 _swigt__p_wxConfigPathChanger,
33003 _swigt__p_wxDateSpan,
33004 0
33005 };
33006
33007
33008 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33009
33010 static swig_const_info swig_const_table[] = {
33011 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33012 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33013 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33014 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33015 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33016 {0, 0, 0, 0.0, 0, 0}};
33017
33018 #ifdef __cplusplus
33019 }
33020 #endif
33021
33022
33023 #ifdef __cplusplus
33024 extern "C" {
33025 #endif
33026
33027 /* Python-specific SWIG API */
33028 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33029 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33030 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33031
33032 /* -----------------------------------------------------------------------------
33033 * global variable support code.
33034 * ----------------------------------------------------------------------------- */
33035
33036 typedef struct swig_globalvar {
33037 char *name; /* Name of global variable */
33038 PyObject *(*get_attr)(); /* Return the current value */
33039 int (*set_attr)(PyObject *); /* Set the value */
33040 struct swig_globalvar *next;
33041 } swig_globalvar;
33042
33043 typedef struct swig_varlinkobject {
33044 PyObject_HEAD
33045 swig_globalvar *vars;
33046 } swig_varlinkobject;
33047
33048 static PyObject *
33049 swig_varlink_repr(swig_varlinkobject *v) {
33050 v = v;
33051 return PyString_FromString("<Swig global variables>");
33052 }
33053
33054 static int
33055 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33056 swig_globalvar *var;
33057 flags = flags;
33058 fprintf(fp,"Swig global variables { ");
33059 for (var = v->vars; var; var=var->next) {
33060 fprintf(fp,"%s", var->name);
33061 if (var->next) fprintf(fp,", ");
33062 }
33063 fprintf(fp," }\n");
33064 return 0;
33065 }
33066
33067 static PyObject *
33068 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33069 swig_globalvar *var = v->vars;
33070 while (var) {
33071 if (strcmp(var->name,n) == 0) {
33072 return (*var->get_attr)();
33073 }
33074 var = var->next;
33075 }
33076 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33077 return NULL;
33078 }
33079
33080 static int
33081 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33082 swig_globalvar *var = v->vars;
33083 while (var) {
33084 if (strcmp(var->name,n) == 0) {
33085 return (*var->set_attr)(p);
33086 }
33087 var = var->next;
33088 }
33089 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33090 return 1;
33091 }
33092
33093 static PyTypeObject varlinktype = {
33094 PyObject_HEAD_INIT(0)
33095 0, /* Number of items in variable part (ob_size) */
33096 (char *)"swigvarlink", /* Type name (tp_name) */
33097 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33098 0, /* Itemsize (tp_itemsize) */
33099 0, /* Deallocator (tp_dealloc) */
33100 (printfunc) swig_varlink_print, /* Print (tp_print) */
33101 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33102 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33103 0, /* tp_compare */
33104 (reprfunc) swig_varlink_repr, /* tp_repr */
33105 0, /* tp_as_number */
33106 0, /* tp_as_sequence */
33107 0, /* tp_as_mapping */
33108 0, /* tp_hash */
33109 0, /* tp_call */
33110 0, /* tp_str */
33111 0, /* tp_getattro */
33112 0, /* tp_setattro */
33113 0, /* tp_as_buffer */
33114 0, /* tp_flags */
33115 0, /* tp_doc */
33116 #if PY_VERSION_HEX >= 0x02000000
33117 0, /* tp_traverse */
33118 0, /* tp_clear */
33119 #endif
33120 #if PY_VERSION_HEX >= 0x02010000
33121 0, /* tp_richcompare */
33122 0, /* tp_weaklistoffset */
33123 #endif
33124 #if PY_VERSION_HEX >= 0x02020000
33125 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33126 #endif
33127 #if PY_VERSION_HEX >= 0x02030000
33128 0, /* tp_del */
33129 #endif
33130 #ifdef COUNT_ALLOCS
33131 0,0,0,0 /* tp_alloc -> tp_next */
33132 #endif
33133 };
33134
33135 /* Create a variable linking object for use later */
33136 static PyObject *
33137 SWIG_Python_newvarlink(void) {
33138 swig_varlinkobject *result = 0;
33139 result = PyMem_NEW(swig_varlinkobject,1);
33140 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33141 result->ob_type = &varlinktype;
33142 result->vars = 0;
33143 result->ob_refcnt = 0;
33144 Py_XINCREF((PyObject *) result);
33145 return ((PyObject*) result);
33146 }
33147
33148 static void
33149 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33150 swig_varlinkobject *v;
33151 swig_globalvar *gv;
33152 v= (swig_varlinkobject *) p;
33153 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33154 gv->name = (char *) malloc(strlen(name)+1);
33155 strcpy(gv->name,name);
33156 gv->get_attr = get_attr;
33157 gv->set_attr = set_attr;
33158 gv->next = v->vars;
33159 v->vars = gv;
33160 }
33161
33162 /* -----------------------------------------------------------------------------
33163 * constants/methods manipulation
33164 * ----------------------------------------------------------------------------- */
33165
33166 /* Install Constants */
33167 static void
33168 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33169 PyObject *obj = 0;
33170 size_t i;
33171 for (i = 0; constants[i].type; i++) {
33172 switch(constants[i].type) {
33173 case SWIG_PY_INT:
33174 obj = PyInt_FromLong(constants[i].lvalue);
33175 break;
33176 case SWIG_PY_FLOAT:
33177 obj = PyFloat_FromDouble(constants[i].dvalue);
33178 break;
33179 case SWIG_PY_STRING:
33180 if (constants[i].pvalue) {
33181 obj = PyString_FromString((char *) constants[i].pvalue);
33182 } else {
33183 Py_INCREF(Py_None);
33184 obj = Py_None;
33185 }
33186 break;
33187 case SWIG_PY_POINTER:
33188 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33189 break;
33190 case SWIG_PY_BINARY:
33191 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33192 break;
33193 default:
33194 obj = 0;
33195 break;
33196 }
33197 if (obj) {
33198 PyDict_SetItemString(d,constants[i].name,obj);
33199 Py_DECREF(obj);
33200 }
33201 }
33202 }
33203
33204 /* -----------------------------------------------------------------------------*/
33205 /* Fix SwigMethods to carry the callback ptrs when needed */
33206 /* -----------------------------------------------------------------------------*/
33207
33208 static void
33209 SWIG_Python_FixMethods(PyMethodDef *methods,
33210 swig_const_info *const_table,
33211 swig_type_info **types,
33212 swig_type_info **types_initial) {
33213 size_t i;
33214 for (i = 0; methods[i].ml_name; ++i) {
33215 char *c = methods[i].ml_doc;
33216 if (c && (c = strstr(c, "swig_ptr: "))) {
33217 int j;
33218 swig_const_info *ci = 0;
33219 char *name = c + 10;
33220 for (j = 0; const_table[j].type; j++) {
33221 if (strncmp(const_table[j].name, name,
33222 strlen(const_table[j].name)) == 0) {
33223 ci = &(const_table[j]);
33224 break;
33225 }
33226 }
33227 if (ci) {
33228 size_t shift = (ci->ptype) - types;
33229 swig_type_info *ty = types_initial[shift];
33230 size_t ldoc = (c - methods[i].ml_doc);
33231 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33232 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33233 char *buff = ndoc;
33234 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33235 strncpy(buff, methods[i].ml_doc, ldoc);
33236 buff += ldoc;
33237 strncpy(buff, "swig_ptr: ", 10);
33238 buff += 10;
33239 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33240 methods[i].ml_doc = ndoc;
33241 }
33242 }
33243 }
33244 }
33245
33246 /* -----------------------------------------------------------------------------*
33247 * Initialize type list
33248 * -----------------------------------------------------------------------------*/
33249
33250 #if PY_MAJOR_VERSION < 2
33251 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33252 is copied out of Python/modsupport.c in python version 2.3.4 */
33253 static int
33254 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33255 {
33256 PyObject *dict;
33257 if (!PyModule_Check(m)) {
33258 PyErr_SetString(PyExc_TypeError,
33259 "PyModule_AddObject() needs module as first arg");
33260 return -1;
33261 }
33262 if (!o) {
33263 PyErr_SetString(PyExc_TypeError,
33264 "PyModule_AddObject() needs non-NULL value");
33265 return -1;
33266 }
33267
33268 dict = PyModule_GetDict(m);
33269 if (dict == NULL) {
33270 /* Internal error -- modules must have a dict! */
33271 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33272 PyModule_GetName(m));
33273 return -1;
33274 }
33275 if (PyDict_SetItemString(dict, name, o))
33276 return -1;
33277 Py_DECREF(o);
33278 return 0;
33279 }
33280 #endif
33281
33282 static swig_type_info **
33283 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33284 static PyMethodDef swig_empty_runtime_method_table[] = {
33285 {
33286 NULL, NULL, 0, NULL
33287 }
33288 };/* Sentinel */
33289
33290 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33291 swig_empty_runtime_method_table);
33292 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33293 if (pointer && module) {
33294 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33295 }
33296 return type_list_handle;
33297 }
33298
33299 static swig_type_info **
33300 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33301 swig_type_info **type_pointer;
33302
33303 /* first check if module already created */
33304 type_pointer = SWIG_Python_GetTypeListHandle();
33305 if (type_pointer) {
33306 return type_pointer;
33307 } else {
33308 /* create a new module and variable */
33309 return SWIG_Python_SetTypeListHandle(type_list_handle);
33310 }
33311 }
33312
33313 #ifdef __cplusplus
33314 }
33315 #endif
33316
33317 /* -----------------------------------------------------------------------------*
33318 * Partial Init method
33319 * -----------------------------------------------------------------------------*/
33320
33321 #ifdef SWIG_LINK_RUNTIME
33322 #ifdef __cplusplus
33323 extern "C"
33324 #endif
33325 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33326 #endif
33327
33328 #ifdef __cplusplus
33329 extern "C"
33330 #endif
33331 SWIGEXPORT(void) SWIG_init(void) {
33332 static PyObject *SWIG_globals = 0;
33333 static int typeinit = 0;
33334 PyObject *m, *d;
33335 int i;
33336 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33337
33338 /* Fix SwigMethods to carry the callback ptrs when needed */
33339 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33340
33341 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33342 d = PyModule_GetDict(m);
33343
33344 if (!typeinit) {
33345 #ifdef SWIG_LINK_RUNTIME
33346 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33347 #else
33348 # ifndef SWIG_STATIC_RUNTIME
33349 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33350 # endif
33351 #endif
33352 for (i = 0; swig_types_initial[i]; i++) {
33353 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33354 }
33355 typeinit = 1;
33356 }
33357 SWIG_InstallConstants(d,swig_const_table);
33358
33359 {
33360 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33361 }
33362 {
33363 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33364 }
33365 {
33366 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33367 }
33368 {
33369 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33370 }
33371 {
33372 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33373 }
33374 {
33375 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33376 }
33377 {
33378 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33379 }
33380 {
33381 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33382 }
33383 {
33384 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33385 }
33386 {
33387 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33388 }
33389 {
33390 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33391 }
33392 {
33393 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33394 }
33395 {
33396 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33397 }
33398 {
33399 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33400 }
33401 {
33402 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33412 }
33413 {
33414 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33415 }
33416 {
33417 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33418 }
33419 {
33420 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33466 }
33467 {
33468 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33469 }
33470 {
33471 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33472 }
33473 {
33474 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33475 }
33476 {
33477 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33478 }
33479 {
33480 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33481 }
33482 {
33483 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33484 }
33485 {
33486 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33490 }
33491 {
33492 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33493 }
33494 {
33495 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33496 }
33497 {
33498 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33499 }
33500 {
33501 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33502 }
33503 {
33504 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33505 }
33506 {
33507 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33508 }
33509 {
33510 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33511 }
33512 {
33513 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33514 }
33515 {
33516 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33517 }
33518 {
33519 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33523 }
33524 {
33525 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33526 }
33527 {
33528 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33529 }
33530 {
33531 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33532 }
33533 {
33534 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33541 }
33542 {
33543 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33544 }
33545 {
33546 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33547 }
33548 {
33549 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33550 }
33551 {
33552 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33553 }
33554 {
33555 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33556 }
33557 {
33558 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33559 }
33560 {
33561 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33562 }
33563 {
33564 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33565 }
33566 {
33567 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33568 }
33569 {
33570 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33571 }
33572 {
33573 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33574 }
33575 {
33576 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33580 }
33581 {
33582 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33583 }
33584 {
33585 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33589 }
33590 {
33591 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33592 }
33593 {
33594 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33595 }
33596 {
33597 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33598 }
33599 {
33600 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33601 }
33602 {
33603 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33604 }
33605 {
33606 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33607 }
33608 {
33609 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33610 }
33611 {
33612 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33613 }
33614 {
33615 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33616 }
33617 {
33618 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33619 }
33620 {
33621 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33622 }
33623 {
33624 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33625 }
33626 {
33627 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33628 }
33629 {
33630 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33631 }
33632 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33633 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33634 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33635 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33636 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33637 {
33638 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33639 }
33640 {
33641 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33642 }
33643 {
33644 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33645 }
33646 {
33647 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33648 }
33649 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33650
33651 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33652
33653 {
33654 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33661 }
33662 {
33663 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33664 }
33665 {
33666 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33667 }
33668 {
33669 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33670 }
33671 {
33672 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33673 }
33674 {
33675 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33676 }
33677 {
33678 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33682 }
33683 {
33684 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33685 }
33686 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33687 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33688 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33689 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33690 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33691 {
33692 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33693 }
33694 {
33695 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33696 }
33697 {
33698 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33699 }
33700 {
33701 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33702 }
33703 {
33704 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33705 }
33706 {
33707 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33708 }
33709 {
33710 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33711 }
33712 {
33713 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33714 }
33715 {
33716 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33717 }
33718 {
33719 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33720 }
33721 {
33722 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33723 }
33724 {
33725 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33726 }
33727 {
33728 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33729 }
33730 {
33731 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33732 }
33733 {
33734 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33735 }
33736 {
33737 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33738 }
33739 {
33740 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33741 }
33742 {
33743 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33744 }
33745 {
33746 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33747 }
33748 {
33749 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33750 }
33751 {
33752 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33753 }
33754 {
33755 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33756 }
33757 {
33758 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33759 }
33760 {
33761 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33762 }
33763 {
33764 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33765 }
33766 {
33767 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33768 }
33769 {
33770 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33771 }
33772 {
33773 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33774 }
33775 {
33776 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33777 }
33778 {
33779 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33780 }
33781 {
33782 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33783 }
33784 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33785 {
33786 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33799 }
33800
33801 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33802
33803 {
33804 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33805 }
33806 {
33807 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33808 }
33809 {
33810 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33811 }
33812 {
33813 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33814 }
33815 {
33816 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33817 }
33818 {
33819 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33820 }
33821 {
33822 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33823 }
33824 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33825 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33826 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33827 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33828 {
33829 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33851 }
33852 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33853 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33854 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33855 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33856 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33857 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33858 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33859 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33860 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33861 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33862 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33863 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33864 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33865 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33866 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33867 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33868 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33869 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33870 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33871 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33872 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33873 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33874 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33875 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33876 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33877 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33878 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33879 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33880 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33881 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33882 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33883 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33884 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33885 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33886 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33887 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33888 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33889 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33890 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33891 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33892 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33893 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33894 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33895 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33896 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33897 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33898 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33899 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33900 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33901 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33902 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33903 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33904 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33905 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33906 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33907 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33908
33909 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33910
33911 {
33912 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33913 }
33914 {
33915 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33916 }
33917 {
33918 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33919 }
33920 {
33921 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33922 }
33923 {
33924 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33925 }
33926 {
33927 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33928 }
33929 {
33930 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33931 }
33932 {
33933 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33934 }
33935 {
33936 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33937 }
33938 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33939 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33940 {
33941 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33942 }
33943 {
33944 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33945 }
33946 {
33947 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33948 }
33949 {
33950 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33951 }
33952 {
33953 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33954 }
33955 {
33956 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33957 }
33958 {
33959 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33960 }
33961 {
33962 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33972 }
33973 {
33974 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33975 }
33976 {
33977 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33978 }
33979 {
33980 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33981 }
33982 {
33983 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33984 }
33985 {
33986 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33987 }
33988 {
33989 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33990 }
33991 {
33992 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33993 }
33994 {
33995 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33996 }
33997 {
33998 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33999 }
34000 {
34001 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34002 }
34003 {
34004 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34005 }
34006 {
34007 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34008 }
34009 {
34010 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34011 }
34012 {
34013 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34014 }
34015 {
34016 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34017 }
34018 {
34019 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34020 }
34021 {
34022 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34023 }
34024 {
34025 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34026 }
34027 {
34028 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34029 }
34030 {
34031 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34032 }
34033 {
34034 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34035 }
34036 {
34037 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34038 }
34039 {
34040 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34041 }
34042 {
34043 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34044 }
34045 {
34046 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34047 }
34048 {
34049 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34050 }
34051 {
34052 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34053 }
34054 {
34055 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34056 }
34057 {
34058 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34059 }
34060 {
34061 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34062 }
34063 {
34064 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34065 }
34066 {
34067 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34068 }
34069 {
34070 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34071 }
34072 {
34073 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34074 }
34075 {
34076 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34077 }
34078 {
34079 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34080 }
34081 {
34082 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34083 }
34084 {
34085 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34086 }
34087 {
34088 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34089 }
34090 {
34091 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34092 }
34093 {
34094 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34095 }
34096 {
34097 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34098 }
34099 {
34100 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34101 }
34102 {
34103 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34104 }
34105 {
34106 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34107 }
34108 {
34109 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34110 }
34111 {
34112 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34113 }
34114 {
34115 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34116 }
34117 {
34118 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34119 }
34120 {
34121 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34122 }
34123 {
34124 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34125 }
34126 {
34127 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34128 }
34129 {
34130 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34131 }
34132 {
34133 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34134 }
34135 {
34136 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34137 }
34138 {
34139 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34140 }
34141 {
34142 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34143 }
34144 {
34145 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34146 }
34147 {
34148 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34149 }
34150 {
34151 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34152 }
34153 {
34154 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34155 }
34156 {
34157 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34158 }
34159 {
34160 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34161 }
34162 {
34163 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34164 }
34165 {
34166 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34167 }
34168 {
34169 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34170 }
34171 {
34172 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34173 }
34174 {
34175 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34176 }
34177 {
34178 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34179 }
34180 {
34181 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34182 }
34183 {
34184 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34185 }
34186 {
34187 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34188 }
34189 {
34190 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34191 }
34192 {
34193 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34194 }
34195 {
34196 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34197 }
34198 {
34199 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34200 }
34201 {
34202 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34203 }
34204 {
34205 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34206 }
34207 {
34208 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34209 }
34210 {
34211 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34212 }
34213 {
34214 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34215 }
34216 {
34217 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34218 }
34219 {
34220 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34221 }
34222 {
34223 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34224 }
34225 {
34226 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34227 }
34228 {
34229 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34230 }
34231 {
34232 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34233 }
34234 {
34235 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34236 }
34237 {
34238 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34239 }
34240 {
34241 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34242 }
34243 {
34244 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34245 }
34246 {
34247 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34248 }
34249 {
34250 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34251 }
34252 {
34253 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34254 }
34255 {
34256 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34257 }
34258 {
34259 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34260 }
34261 {
34262 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34263 }
34264 {
34265 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34266 }
34267 {
34268 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34269 }
34270 {
34271 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34272 }
34273 {
34274 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34275 }
34276 {
34277 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34278 }
34279 {
34280 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34281 }
34282 {
34283 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34284 }
34285 {
34286 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34287 }
34288 {
34289 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34290 }
34291 {
34292 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34293 }
34294 {
34295 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34296 }
34297 {
34298 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34299 }
34300 {
34301 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34302 }
34303 {
34304 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34305 }
34306 {
34307 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34308 }
34309 {
34310 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34311 }
34312 {
34313 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34314 }
34315 {
34316 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34317 }
34318 {
34319 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34320 }
34321 {
34322 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34323 }
34324 {
34325 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34326 }
34327 {
34328 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34329 }
34330 {
34331 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34332 }
34333 {
34334 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34335 }
34336 {
34337 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34338 }
34339 {
34340 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34341 }
34342 {
34343 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34344 }
34345 {
34346 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34347 }
34348 {
34349 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34350 }
34351 {
34352 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34353 }
34354 {
34355 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34356 }
34357 {
34358 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34359 }
34360 {
34361 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34362 }
34363 {
34364 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34365 }
34366 {
34367 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34368 }
34369 {
34370 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34371 }
34372 {
34373 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34374 }
34375 {
34376 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34377 }
34378 {
34379 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34380 }
34381 {
34382 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34383 }
34384 {
34385 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34386 }
34387 {
34388 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34389 }
34390 {
34391 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34392 }
34393 {
34394 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34395 }
34396 {
34397 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34398 }
34399 {
34400 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34401 }
34402 {
34403 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34404 }
34405 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34406 {
34407 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34408 }
34409 {
34410 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34411 }
34412 {
34413 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34414 }
34415 {
34416 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34417 }
34418 {
34419 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34420 }
34421 {
34422 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34423 }
34424 {
34425 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34426 }
34427 {
34428 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34429 }
34430 {
34431 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34432 }
34433 {
34434 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34435 }
34436 {
34437 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34438 }
34439 {
34440 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34441 }
34442 {
34443 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34444 }
34445 {
34446 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34447 }
34448 {
34449 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34450 }
34451 {
34452 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34453 }
34454 {
34455 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34456 }
34457 {
34458 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34459 }
34460 {
34461 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34462 }
34463 {
34464 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34465 }
34466 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34467 {
34468 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34469 }
34470 {
34471 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34472 }
34473 {
34474 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34475 }
34476 {
34477 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34478 }
34479 {
34480 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34481 }
34482 {
34483 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34484 }
34485 {
34486 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34487 }
34488 {
34489 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34490 }
34491 {
34492 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34493 }
34494 {
34495 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34496 }
34497 {
34498 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34499 }
34500 {
34501 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34502 }
34503
34504 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34505 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34506 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34507 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34508
34509 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34510 }
34511
wxWidgets (Impactor)