]> 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
Don't use the python version in the srpm name
[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_void swig_types[18]
1361 #define SWIGTYPE_p_int swig_types[19]
1362 #define SWIGTYPE_p_wxSize swig_types[20]
1363 #define SWIGTYPE_p_wxClipboard swig_types[21]
1364 #define SWIGTYPE_p_wxStopWatch swig_types[22]
1365 #define SWIGTYPE_p_wxDC swig_types[23]
1366 #define SWIGTYPE_p_wxClipboardLocker swig_types[24]
1367 #define SWIGTYPE_p_wxIcon swig_types[25]
1368 #define SWIGTYPE_p_wxLogStderr swig_types[26]
1369 #define SWIGTYPE_p_wxLogTextCtrl swig_types[27]
1370 #define SWIGTYPE_p_wxTextCtrl swig_types[28]
1371 #define SWIGTYPE_p_wxBusyCursor swig_types[29]
1372 #define SWIGTYPE_p_wxBitmapDataObject swig_types[30]
1373 #define SWIGTYPE_p_wxTextDataObject swig_types[31]
1374 #define SWIGTYPE_p_wxDataObject swig_types[32]
1375 #define SWIGTYPE_p_wxPyTextDataObject swig_types[33]
1376 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[34]
1377 #define SWIGTYPE_p_wxFileDataObject swig_types[35]
1378 #define SWIGTYPE_p_wxCustomDataObject swig_types[36]
1379 #define SWIGTYPE_p_wxURLDataObject swig_types[37]
1380 #define SWIGTYPE_p_wxMetafileDataObject swig_types[38]
1381 #define SWIGTYPE_p_wxSound swig_types[39]
1382 #define SWIGTYPE_p_wxTimerRunner swig_types[40]
1383 #define SWIGTYPE_p_wxLogWindow swig_types[41]
1384 #define SWIGTYPE_p_wxTimeSpan swig_types[42]
1385 #define SWIGTYPE_p_wxArrayString swig_types[43]
1386 #define SWIGTYPE_p_wxWindowDisabler swig_types[44]
1387 #define SWIGTYPE_p_form_ops_t swig_types[45]
1388 #define SWIGTYPE_p_wxToolTip swig_types[46]
1389 #define SWIGTYPE_p_wxDataObjectComposite swig_types[47]
1390 #define SWIGTYPE_p_wxSystemSettings swig_types[48]
1391 #define SWIGTYPE_p_wxFileConfig swig_types[49]
1392 #define SWIGTYPE_p_wxVideoMode swig_types[50]
1393 #define SWIGTYPE_p_wxDataObjectSimple swig_types[51]
1394 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[52]
1395 #define SWIGTYPE_p_wxDuplexMode swig_types[53]
1396 #define SWIGTYPE_p_wxEvtHandler swig_types[54]
1397 #define SWIGTYPE_p_wxRect swig_types[55]
1398 #define SWIGTYPE_p_char swig_types[56]
1399 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[57]
1400 #define SWIGTYPE_p_wxStandardPaths swig_types[58]
1401 #define SWIGTYPE_p_wxFileTypeInfo swig_types[59]
1402 #define SWIGTYPE_p_wxFrame swig_types[60]
1403 #define SWIGTYPE_p_wxTimer swig_types[61]
1404 #define SWIGTYPE_p_wxPaperSize swig_types[62]
1405 #define SWIGTYPE_p_wxMimeTypesManager swig_types[63]
1406 #define SWIGTYPE_p_wxPyArtProvider swig_types[64]
1407 #define SWIGTYPE_p_wxPyTipProvider swig_types[65]
1408 #define SWIGTYPE_p_wxTipProvider swig_types[66]
1409 #define SWIGTYPE_p_wxJoystick swig_types[67]
1410 #define SWIGTYPE_p_wxSystemOptions swig_types[68]
1411 #define SWIGTYPE_p_wxPoint swig_types[69]
1412 #define SWIGTYPE_p_wxJoystickEvent swig_types[70]
1413 #define SWIGTYPE_p_wxCursor swig_types[71]
1414 #define SWIGTYPE_p_wxObject swig_types[72]
1415 #define SWIGTYPE_p_wxOutputStream swig_types[73]
1416 #define SWIGTYPE_p_wxDateTime swig_types[74]
1417 #define SWIGTYPE_p_wxPyDropSource swig_types[75]
1418 #define SWIGTYPE_p_unsigned_long swig_types[76]
1419 #define SWIGTYPE_p_wxKillError swig_types[77]
1420 #define SWIGTYPE_p_wxWindow swig_types[78]
1421 #define SWIGTYPE_p_wxString swig_types[79]
1422 #define SWIGTYPE_p_wxPyProcess swig_types[80]
1423 #define SWIGTYPE_p_wxBitmap swig_types[81]
1424 #define SWIGTYPE_unsigned_int swig_types[82]
1425 #define SWIGTYPE_p_unsigned_int swig_types[83]
1426 #define SWIGTYPE_p_wxConfig swig_types[84]
1427 #define SWIGTYPE_p_unsigned_char swig_types[85]
1428 #define SWIGTYPE_p_wxChar swig_types[86]
1429 #define SWIGTYPE_p_wxBusyInfo swig_types[87]
1430 #define SWIGTYPE_p_wxPyDropTarget swig_types[88]
1431 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[89]
1432 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[90]
1433 #define SWIGTYPE_p_wxProcessEvent swig_types[91]
1434 #define SWIGTYPE_p_wxPyLog swig_types[92]
1435 #define SWIGTYPE_p_wxLogNull swig_types[93]
1436 #define SWIGTYPE_p_wxColour swig_types[94]
1437 #define SWIGTYPE_p_wxPyTimer swig_types[95]
1438 #define SWIGTYPE_p_wxConfigPathChanger swig_types[96]
1439 #define SWIGTYPE_p_wxDateSpan swig_types[97]
1440 static swig_type_info *swig_types[99];
1441
1442 /* -------- TYPES TABLE (END) -------- */
1443
1444
1445 /*-----------------------------------------------
1446 @(target):= _misc_.so
1447 ------------------------------------------------*/
1448 #define SWIG_init init_misc_
1449
1450 #define SWIG_name "_misc_"
1451
1452 #include "wx/wxPython/wxPython.h"
1453 #include "wx/wxPython/pyclasses.h"
1454 #include "wx/wxPython/pyistream.h"
1455
1456 static const wxString wxPyEmptyString(wxEmptyString);
1457
1458
1459
1460 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1461 #define SWIG_From_int PyInt_FromLong
1462 /*@@*/
1463
1464
1465 #include <limits.h>
1466
1467
1468 SWIGINTERN int
1469 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1470 const char *errmsg)
1471 {
1472 if (value < min_value) {
1473 if (errmsg) {
1474 PyErr_Format(PyExc_OverflowError,
1475 "value %ld is less than '%s' minimum %ld",
1476 value, errmsg, min_value);
1477 }
1478 return 0;
1479 } else if (value > max_value) {
1480 if (errmsg) {
1481 PyErr_Format(PyExc_OverflowError,
1482 "value %ld is greater than '%s' maximum %ld",
1483 value, errmsg, max_value);
1484 }
1485 return 0;
1486 }
1487 return 1;
1488 }
1489
1490
1491 SWIGINTERN int
1492 SWIG_AsVal_long(PyObject* obj, long* val)
1493 {
1494 if (PyNumber_Check(obj)) {
1495 if (val) *val = PyInt_AsLong(obj);
1496 return 1;
1497 }
1498 else {
1499 SWIG_type_error("number", obj);
1500 }
1501 return 0;
1502 }
1503
1504
1505 #if INT_MAX != LONG_MAX
1506 SWIGINTERN int
1507 SWIG_AsVal_int(PyObject *obj, int *val)
1508 {
1509 const char* errmsg = val ? "int" : (char*)0;
1510 long v;
1511 if (SWIG_AsVal_long(obj, &v)) {
1512 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1513 if (val) *val = (int)(v);
1514 return 1;
1515 } else {
1516 return 0;
1517 }
1518 } else {
1519 PyErr_Clear();
1520 }
1521 if (val) {
1522 SWIG_type_error(errmsg, obj);
1523 }
1524 return 0;
1525 }
1526 #else
1527 SWIGINTERNSHORT int
1528 SWIG_AsVal_int(PyObject *obj, int *val)
1529 {
1530 return SWIG_AsVal_long(obj,(long*)val);
1531 }
1532 #endif
1533
1534
1535 SWIGINTERNSHORT int
1536 SWIG_As_int(PyObject* obj)
1537 {
1538 int v;
1539 if (!SWIG_AsVal_int(obj, &v)) {
1540 /*
1541 this is needed to make valgrind/purify happier.
1542 */
1543 memset((void*)&v, 0, sizeof(int));
1544 }
1545 return v;
1546 }
1547
1548
1549 SWIGINTERNSHORT int
1550 SWIG_Check_int(PyObject* obj)
1551 {
1552 return SWIG_AsVal_int(obj, (int*)0);
1553 }
1554
1555 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1556
1557 #include <wx/stockitem.h>
1558
1559 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1560 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1561 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1562
1563 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1564 #define SWIG_From_long PyInt_FromLong
1565 /*@@*/
1566
1567
1568 SWIGINTERNSHORT long
1569 SWIG_As_long(PyObject* obj)
1570 {
1571 long v;
1572 if (!SWIG_AsVal_long(obj, &v)) {
1573 /*
1574 this is needed to make valgrind/purify happier.
1575 */
1576 memset((void*)&v, 0, sizeof(long));
1577 }
1578 return v;
1579 }
1580
1581
1582 SWIGINTERNSHORT int
1583 SWIG_Check_long(PyObject* obj)
1584 {
1585 return SWIG_AsVal_long(obj, (long*)0);
1586 }
1587
1588
1589 SWIGINTERN int
1590 SWIG_AsVal_bool(PyObject *obj, bool *val)
1591 {
1592 if (obj == Py_True) {
1593 if (val) *val = true;
1594 return 1;
1595 }
1596 if (obj == Py_False) {
1597 if (val) *val = false;
1598 return 1;
1599 }
1600 int res = 0;
1601 if (SWIG_AsVal_int(obj, &res)) {
1602 if (val) *val = res ? true : false;
1603 return 1;
1604 } else {
1605 PyErr_Clear();
1606 }
1607 if (val) {
1608 SWIG_type_error("bool", obj);
1609 }
1610 return 0;
1611 }
1612
1613
1614 SWIGINTERNSHORT bool
1615 SWIG_As_bool(PyObject* obj)
1616 {
1617 bool v;
1618 if (!SWIG_AsVal_bool(obj, &v)) {
1619 /*
1620 this is needed to make valgrind/purify happier.
1621 */
1622 memset((void*)&v, 0, sizeof(bool));
1623 }
1624 return v;
1625 }
1626
1627
1628 SWIGINTERNSHORT int
1629 SWIG_Check_bool(PyObject* obj)
1630 {
1631 return SWIG_AsVal_bool(obj, (bool*)0);
1632 }
1633
1634
1635 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1636 PyObject* o2;
1637 PyObject* o3;
1638
1639 if (!target) {
1640 target = o;
1641 } else if (target == Py_None) {
1642 Py_DECREF(Py_None);
1643 target = o;
1644 } else {
1645 if (!PyTuple_Check(target)) {
1646 o2 = target;
1647 target = PyTuple_New(1);
1648 PyTuple_SetItem(target, 0, o2);
1649 }
1650 o3 = PyTuple_New(1);
1651 PyTuple_SetItem(o3, 0, o);
1652
1653 o2 = target;
1654 target = PySequence_Concat(o2, o3);
1655 Py_DECREF(o2);
1656 Py_DECREF(o3);
1657 }
1658 return target;
1659 }
1660
1661
1662
1663 SWIGINTERN int
1664 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1665 {
1666 long v = 0;
1667 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1668 SWIG_type_error("unsigned number", obj);
1669 }
1670 else if (val)
1671 *val = (unsigned long)v;
1672 return 1;
1673 }
1674
1675
1676 SWIGINTERNSHORT unsigned long
1677 SWIG_As_unsigned_SS_long(PyObject* obj)
1678 {
1679 unsigned long v;
1680 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1681 /*
1682 this is needed to make valgrind/purify happier.
1683 */
1684 memset((void*)&v, 0, sizeof(unsigned long));
1685 }
1686 return v;
1687 }
1688
1689
1690 SWIGINTERNSHORT int
1691 SWIG_Check_unsigned_SS_long(PyObject* obj)
1692 {
1693 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1694 }
1695
1696
1697 SWIGINTERNSHORT PyObject*
1698 SWIG_From_unsigned_SS_long(unsigned long value)
1699 {
1700 return (value > LONG_MAX) ?
1701 PyLong_FromUnsignedLong(value)
1702 : PyInt_FromLong((long)(value));
1703 }
1704
1705
1706 void* wxGetXDisplay()
1707 {
1708 #ifdef __WXGTK__
1709 return wxGetDisplay();
1710 #else
1711 return NULL;
1712 #endif
1713 }
1714
1715
1716 bool wxThread_IsMain() {
1717 #ifdef WXP_WITH_THREAD
1718 return wxThread::IsMain();
1719 #else
1720 return true;
1721 #endif
1722 }
1723
1724 static void wxCaret_Destroy(wxCaret *self){
1725 delete self;
1726 }
1727
1728 #include <wx/snglinst.h>
1729
1730
1731 #ifdef __WXMSW__
1732 #include <wx/msw/private.h>
1733 #include <wx/dynload.h>
1734 #endif
1735
1736
1737
1738 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1739 #if 0
1740 , int method
1741 #endif
1742 )
1743 {
1744 #ifdef __WXMSW__
1745 #if 0
1746 switch (method)
1747 {
1748 case 1:
1749 // This one only partially works. Appears to be an undocumented
1750 // "standard" convention that not all widgets adhear to. For
1751 // example, for some widgets backgrounds or non-client areas may
1752 // not be painted.
1753 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1754 break;
1755
1756 case 2:
1757 #endif
1758 // This one works much better, nearly all widgets and their
1759 // children are captured correctly[**]. Prior to the big
1760 // background erase changes that Vadim did in 2004-2005 this
1761 // method failed badly on XP with Themes activated, most native
1762 // widgets draw only partially, if at all. Without themes it
1763 // worked just like on Win2k. After those changes this method
1764 // works very well.
1765 //
1766 // ** For example the radio buttons in a wxRadioBox are not its
1767 // children by default, but you can capture it via the panel
1768 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1769 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1770 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1771 PRF_ERASEBKGND | PRF_OWNED );
1772 return true;
1773 #if 0
1774 break;
1775
1776 case 3:
1777 // This one is only defined in the latest SDK and is only
1778 // available on XP. MSDN says it is similar to sending WM_PRINT
1779 // so I expect that it will work similar to the above. Since it
1780 // is avaialble only on XP, it can't be compiled like this and
1781 // will have to be loaded dynamically.
1782 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1783
1784 // fall through
1785
1786 case 4:
1787 // Use PrintWindow if available, or fallback to WM_PRINT
1788 // otherwise. Unfortunately using PrintWindow is even worse than
1789 // WM_PRINT. For most native widgets nothing is drawn to the dc
1790 // at all, with or without Themes.
1791 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1792 static bool s_triedToLoad = false;
1793 static PrintWindow_t pfnPrintWindow = NULL;
1794 if ( !s_triedToLoad )
1795 {
1796
1797 s_triedToLoad = true;
1798 wxDynamicLibrary dllUser32(_T("user32.dll"));
1799 if ( dllUser32.IsLoaded() )
1800 {
1801 wxLogNull nolog; // Don't report errors here
1802 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1803 }
1804 }
1805 if (pfnPrintWindow)
1806 {
1807 //printf("Using PrintWindow\n");
1808 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1809 }
1810 else
1811 {
1812 //printf("Using WM_PRINT\n");
1813 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1814 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1815 PRF_ERASEBKGND | PRF_OWNED );
1816 }
1817 }
1818 #endif // 0
1819 #else
1820 return false;
1821 #endif // __WXMSW__
1822 }
1823
1824
1825
1826 #include <wx/tipdlg.h>
1827
1828
1829 class wxPyTipProvider : public wxTipProvider {
1830 public:
1831 wxPyTipProvider(size_t currentTip)
1832 : wxTipProvider(currentTip) {}
1833
1834 DEC_PYCALLBACK_STRING__pure(GetTip);
1835 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1836 PYPRIVATE;
1837 };
1838
1839 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1840 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1841
1842
1843 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1844
1845 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1846
1847 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1848 : wxTimer(owner, id)
1849 {
1850 if (owner == NULL) SetOwner(this);
1851 }
1852
1853
1854 void wxPyTimer::Notify() {
1855 bool found;
1856 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1857 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1858 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1859 wxPyEndBlockThreads(blocked);
1860 if (! found)
1861 wxTimer::Notify();
1862 }
1863 void wxPyTimer::base_Notify() {
1864 wxTimer::Notify();
1865 }
1866
1867
1868
1869 SWIGINTERN PyObject *
1870 SWIG_FromCharPtr(const char* cptr)
1871 {
1872 if (cptr) {
1873 size_t size = strlen(cptr);
1874 if (size > INT_MAX) {
1875 return SWIG_NewPointerObj((char*)(cptr),
1876 SWIG_TypeQuery("char *"), 0);
1877 } else {
1878 if (size != 0) {
1879 return PyString_FromStringAndSize(cptr, size);
1880 } else {
1881 return PyString_FromString(cptr);
1882 }
1883 }
1884 }
1885 Py_INCREF(Py_None);
1886 return Py_None;
1887 }
1888
1889
1890 SWIGINTERNSHORT int
1891 SWIG_CheckUnsignedLongInRange(unsigned long value,
1892 unsigned long max_value,
1893 const char *errmsg)
1894 {
1895 if (value > max_value) {
1896 if (errmsg) {
1897 PyErr_Format(PyExc_OverflowError,
1898 "value %lu is greater than '%s' minimum %lu",
1899 value, errmsg, max_value);
1900 }
1901 return 0;
1902 }
1903 return 1;
1904 }
1905
1906
1907 #if UINT_MAX != ULONG_MAX
1908 SWIGINTERN int
1909 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1910 {
1911 const char* errmsg = val ? "unsigned int" : (char*)0;
1912 unsigned long v;
1913 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1914 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1915 if (val) *val = (unsigned int)(v);
1916 return 1;
1917 }
1918 } else {
1919 PyErr_Clear();
1920 }
1921 if (val) {
1922 SWIG_type_error(errmsg, obj);
1923 }
1924 return 0;
1925 }
1926 #else
1927 SWIGINTERNSHORT unsigned int
1928 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1929 {
1930 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1931 }
1932 #endif
1933
1934
1935 SWIGINTERNSHORT unsigned int
1936 SWIG_As_unsigned_SS_int(PyObject* obj)
1937 {
1938 unsigned int v;
1939 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1940 /*
1941 this is needed to make valgrind/purify happier.
1942 */
1943 memset((void*)&v, 0, sizeof(unsigned int));
1944 }
1945 return v;
1946 }
1947
1948
1949 SWIGINTERNSHORT int
1950 SWIG_Check_unsigned_SS_int(PyObject* obj)
1951 {
1952 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1953 }
1954
1955 static wxString Log_TimeStamp(){
1956 wxString msg;
1957 wxLog::TimeStamp(&msg);
1958 return msg;
1959 }
1960 static void wxLog_Destroy(wxLog *self){ delete self; }
1961 // Make somce wrappers that double any % signs so they are 'escaped'
1962 void wxPyLogFatalError(const wxString& msg)
1963 {
1964 wxString m(msg);
1965 m.Replace(wxT("%"), wxT("%%"));
1966 wxLogFatalError(m);
1967 }
1968
1969 void wxPyLogError(const wxString& msg)
1970 {
1971 wxString m(msg);
1972 m.Replace(wxT("%"), wxT("%%"));
1973 wxLogError(m);
1974 }
1975
1976 void wxPyLogWarning(const wxString& msg)
1977 {
1978 wxString m(msg);
1979 m.Replace(wxT("%"), wxT("%%"));
1980 wxLogWarning(m);
1981 }
1982
1983 void wxPyLogMessage(const wxString& msg)
1984 {
1985 wxString m(msg);
1986 m.Replace(wxT("%"), wxT("%%"));
1987 wxLogMessage(m);
1988 }
1989
1990 void wxPyLogInfo(const wxString& msg)
1991 {
1992 wxString m(msg);
1993 m.Replace(wxT("%"), wxT("%%"));
1994 wxLogInfo(m);
1995 }
1996
1997 void wxPyLogDebug(const wxString& msg)
1998 {
1999 wxString m(msg);
2000 m.Replace(wxT("%"), wxT("%%"));
2001 wxLogDebug(m);
2002 }
2003
2004 void wxPyLogVerbose(const wxString& msg)
2005 {
2006 wxString m(msg);
2007 m.Replace(wxT("%"), wxT("%%"));
2008 wxLogVerbose(m);
2009 }
2010
2011 void wxPyLogStatus(const wxString& msg)
2012 {
2013 wxString m(msg);
2014 m.Replace(wxT("%"), wxT("%%"));
2015 wxLogStatus(m);
2016 }
2017
2018 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2019 {
2020 wxString m(msg);
2021 m.Replace(wxT("%"), wxT("%%"));
2022 wxLogStatus(pFrame, m);
2023 }
2024
2025 void wxPyLogSysError(const wxString& msg)
2026 {
2027 wxString m(msg);
2028 m.Replace(wxT("%"), wxT("%%"));
2029 wxLogSysError(m);
2030 }
2031
2032 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2033 {
2034 wxString m(msg);
2035 m.Replace(wxT("%"), wxT("%%"));
2036 wxLogGeneric(level, m);
2037 }
2038
2039 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2040 {
2041 wxString m(msg);
2042 m.Replace(wxT("%"), wxT("%%"));
2043 wxLogTrace(mask, m);
2044 }
2045
2046 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2047 {
2048 wxString m(msg);
2049 m.Replace(wxT("%"), wxT("%%"));
2050 wxLogTrace(mask, m);
2051 }
2052
2053
2054
2055 // A wxLog class that can be derived from in wxPython
2056 class wxPyLog : public wxLog {
2057 public:
2058 wxPyLog() : wxLog() {}
2059
2060 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2061 bool found;
2062 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2063 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2064 PyObject* s = wx2PyString(szString);
2065 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2066 Py_DECREF(s);
2067 }
2068 wxPyEndBlockThreads(blocked);
2069 if (! found)
2070 wxLog::DoLog(level, szString, t);
2071 }
2072
2073 virtual void DoLogString(const wxChar *szString, time_t t) {
2074 bool found;
2075 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2076 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2077 PyObject* s = wx2PyString(szString);
2078 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2079 Py_DECREF(s);
2080 }
2081 wxPyEndBlockThreads(blocked);
2082 if (! found)
2083 wxLog::DoLogString(szString, t);
2084 }
2085
2086 PYPRIVATE;
2087 };
2088
2089
2090
2091
2092 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2093
2094
2095 #include <wx/joystick.h>
2096
2097
2098 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2099 // A C++ stub class for wxJoystick for platforms that don't have it.
2100 class wxJoystick : public wxObject {
2101 public:
2102 wxJoystick(int joystick = wxJOYSTICK1) {
2103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2104 PyErr_SetString(PyExc_NotImplementedError,
2105 "wxJoystick is not available on this platform.");
2106 wxPyEndBlockThreads(blocked);
2107 }
2108 wxPoint GetPosition() { return wxPoint(-1,-1); }
2109 int GetZPosition() { return -1; }
2110 int GetButtonState() { return -1; }
2111 int GetPOVPosition() { return -1; }
2112 int GetPOVCTSPosition() { return -1; }
2113 int GetRudderPosition() { return -1; }
2114 int GetUPosition() { return -1; }
2115 int GetVPosition() { return -1; }
2116 int GetMovementThreshold() { return -1; }
2117 void SetMovementThreshold(int threshold) {}
2118
2119 bool IsOk(void) { return false; }
2120 int GetNumberJoysticks() { return -1; }
2121 int GetManufacturerId() { return -1; }
2122 int GetProductId() { return -1; }
2123 wxString GetProductName() { return wxEmptyString; }
2124 int GetXMin() { return -1; }
2125 int GetYMin() { return -1; }
2126 int GetZMin() { return -1; }
2127 int GetXMax() { return -1; }
2128 int GetYMax() { return -1; }
2129 int GetZMax() { return -1; }
2130 int GetNumberButtons() { return -1; }
2131 int GetNumberAxes() { return -1; }
2132 int GetMaxButtons() { return -1; }
2133 int GetMaxAxes() { return -1; }
2134 int GetPollingMin() { return -1; }
2135 int GetPollingMax() { return -1; }
2136 int GetRudderMin() { return -1; }
2137 int GetRudderMax() { return -1; }
2138 int GetUMin() { return -1; }
2139 int GetUMax() { return -1; }
2140 int GetVMin() { return -1; }
2141 int GetVMax() { return -1; }
2142
2143 bool HasRudder() { return false; }
2144 bool HasZ() { return false; }
2145 bool HasU() { return false; }
2146 bool HasV() { return false; }
2147 bool HasPOV() { return false; }
2148 bool HasPOV4Dir() { return false; }
2149 bool HasPOVCTS() { return false; }
2150
2151 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2152 bool ReleaseCapture() { return false; }
2153 };
2154 #endif
2155
2156
2157 #include <wx/sound.h>
2158
2159
2160 #if !wxUSE_SOUND
2161 // A C++ stub class for wxWave for platforms that don't have it.
2162 class wxSound : public wxObject
2163 {
2164 public:
2165 wxSound() {
2166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171 wxSound(const wxString&/*, bool*/) {
2172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2173 PyErr_SetString(PyExc_NotImplementedError,
2174 "wxSound is not available on this platform.");
2175 wxPyEndBlockThreads(blocked);
2176 }
2177 wxSound(int, const wxByte*) {
2178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2179 PyErr_SetString(PyExc_NotImplementedError,
2180 "wxSound is not available on this platform.");
2181 wxPyEndBlockThreads(blocked);
2182 }
2183
2184 ~wxSound() {};
2185
2186 bool Create(const wxString&/*, bool*/) { return false; }
2187 bool Create(int, const wxByte*) { return false; };
2188 bool IsOk() { return false; };
2189 bool Play(unsigned) const { return false; }
2190 static bool Play(const wxString&, unsigned) { return false; }
2191 static void Stop() {}
2192 };
2193
2194 #endif
2195
2196 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2197 if (fileName.Length() == 0)
2198 return new wxSound;
2199 else
2200 return new wxSound(fileName);
2201 }
2202 static wxSound *new_wxSound(PyObject *data){
2203 unsigned char* buffer; int size;
2204 wxSound *sound = NULL;
2205
2206 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2207 if (!PyArg_Parse(data, "t#", &buffer, &size))
2208 goto done;
2209 sound = new wxSound(size, buffer);
2210 done:
2211 wxPyEndBlockThreads(blocked);
2212 return sound;
2213 }
2214 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2215 #ifndef __WXMAC__
2216 unsigned char* buffer;
2217 int size;
2218 bool rv = false;
2219
2220 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2221 if (!PyArg_Parse(data, "t#", &buffer, &size))
2222 goto done;
2223 rv = self->Create(size, buffer);
2224 done:
2225 wxPyEndBlockThreads(blocked);
2226 return rv;
2227 #else
2228 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2229 PyErr_SetString(PyExc_NotImplementedError,
2230 "Create from data is not available on this platform.");
2231 wxPyEndBlockThreads(blocked);
2232 return false;
2233 #endif
2234 }
2235
2236 #include <wx/mimetype.h>
2237
2238 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2239 wxString str;
2240 if (self->GetMimeType(&str))
2241 return wx2PyString(str);
2242 else
2243 RETURN_NONE();
2244 }
2245 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2246 wxArrayString arr;
2247 if (self->GetMimeTypes(arr))
2248 return wxArrayString2PyList_helper(arr);
2249 else
2250 RETURN_NONE();
2251 }
2252 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2253 wxArrayString arr;
2254 if (self->GetExtensions(arr))
2255 return wxArrayString2PyList_helper(arr);
2256 else
2257 RETURN_NONE();
2258 }
2259 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2260 wxIconLocation loc;
2261 if (self->GetIcon(&loc))
2262 return new wxIcon(loc);
2263 else
2264 return NULL;
2265 }
2266 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2267 wxIconLocation loc;
2268 if (self->GetIcon(&loc)) {
2269 wxString iconFile = loc.GetFileName();
2270 int iconIndex = -1;
2271
2272
2273
2274 // Make a tuple and put the values in it
2275 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2276 PyObject* tuple = PyTuple_New(3);
2277 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2278 wxT("wxIcon"), true));
2279 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2280 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2281 wxPyEndBlockThreads(blocked);
2282 return tuple;
2283 }
2284 else
2285 RETURN_NONE();
2286 }
2287 static PyObject *wxFileType_GetDescription(wxFileType *self){
2288 wxString str;
2289 if (self->GetDescription(&str))
2290 return wx2PyString(str);
2291 else
2292 RETURN_NONE();
2293 }
2294 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2295 wxString str;
2296 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2297 return wx2PyString(str);
2298 else
2299 RETURN_NONE();
2300 }
2301 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2302 wxString str;
2303 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2304 return wx2PyString(str);
2305 else
2306 RETURN_NONE();
2307 }
2308 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2309 wxArrayString verbs;
2310 wxArrayString commands;
2311 if (self->GetAllCommands(&verbs, &commands,
2312 wxFileType::MessageParameters(filename, mimetype))) {
2313 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2314 PyObject* tuple = PyTuple_New(2);
2315 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2316 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2317 wxPyEndBlockThreads(blocked);
2318 return tuple;
2319 }
2320 else
2321 RETURN_NONE();
2322 }
2323 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2324 return wxFileType::ExpandCommand(command,
2325 wxFileType::MessageParameters(filename, mimetype));
2326 }
2327 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2328 wxArrayString arr;
2329 self->EnumAllFileTypes(arr);
2330 return wxArrayString2PyList_helper(arr);
2331 }
2332
2333 #include <wx/artprov.h>
2334
2335 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2336 static const wxString wxPyART_MENU(wxART_MENU);
2337 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2338 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2339 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2340 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2341 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2342 static const wxString wxPyART_OTHER(wxART_OTHER);
2343 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2344 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2345 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2346 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2347 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2348 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2349 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2350 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2351 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2352 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2353 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2354 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2355 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2356 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2357 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2358 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2359 static const wxString wxPyART_PRINT(wxART_PRINT);
2360 static const wxString wxPyART_HELP(wxART_HELP);
2361 static const wxString wxPyART_TIP(wxART_TIP);
2362 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2363 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2364 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2365 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2366 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2367 static const wxString wxPyART_CDROM(wxART_CDROM);
2368 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2369 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2370 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2371 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2372 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2373 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2374 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2375 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2376 static const wxString wxPyART_ERROR(wxART_ERROR);
2377 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2378 static const wxString wxPyART_WARNING(wxART_WARNING);
2379 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2380 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2381 static const wxString wxPyART_COPY(wxART_COPY);
2382 static const wxString wxPyART_CUT(wxART_CUT);
2383 static const wxString wxPyART_PASTE(wxART_PASTE);
2384 static const wxString wxPyART_DELETE(wxART_DELETE);
2385 static const wxString wxPyART_NEW(wxART_NEW);
2386 static const wxString wxPyART_UNDO(wxART_UNDO);
2387 static const wxString wxPyART_REDO(wxART_REDO);
2388 static const wxString wxPyART_QUIT(wxART_QUIT);
2389 static const wxString wxPyART_FIND(wxART_FIND);
2390 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2391 // Python aware wxArtProvider
2392 class wxPyArtProvider : public wxArtProvider {
2393 public:
2394
2395 virtual wxBitmap CreateBitmap(const wxArtID& id,
2396 const wxArtClient& client,
2397 const wxSize& size) {
2398 wxBitmap rval = wxNullBitmap;
2399 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2400 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2401 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2402 PyObject* ro;
2403 wxBitmap* ptr;
2404 PyObject* s1, *s2;
2405 s1 = wx2PyString(id);
2406 s2 = wx2PyString(client);
2407 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2408 Py_DECREF(so);
2409 Py_DECREF(s1);
2410 Py_DECREF(s2);
2411 if (ro) {
2412 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2413 rval = *ptr;
2414 Py_DECREF(ro);
2415 }
2416 }
2417 wxPyEndBlockThreads(blocked);
2418 return rval;
2419 }
2420
2421 PYPRIVATE;
2422 };
2423
2424 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2425
2426
2427
2428 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2429 PyObject* ret = PyTuple_New(3);
2430 if (ret) {
2431 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2432 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2433 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2434 }
2435 return ret;
2436 }
2437
2438 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2439 bool cont;
2440 long index = 0;
2441 wxString value;
2442
2443 cont = self->GetFirstGroup(value, index);
2444 return __EnumerationHelper(cont, value, index);
2445 }
2446 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2447 bool cont;
2448 wxString value;
2449
2450 cont = self->GetNextGroup(value, index);
2451 return __EnumerationHelper(cont, value, index);
2452 }
2453 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2454 bool cont;
2455 long index = 0;
2456 wxString value;
2457
2458 cont = self->GetFirstEntry(value, index);
2459 return __EnumerationHelper(cont, value, index);
2460 }
2461 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2462 bool cont;
2463 wxString value;
2464
2465 cont = self->GetNextEntry(value, index);
2466 return __EnumerationHelper(cont, value, index);
2467 }
2468 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2469 long rv;
2470 self->Read(key, &rv, defaultVal);
2471 return rv;
2472 }
2473
2474 SWIGINTERN int
2475 SWIG_AsVal_double(PyObject *obj, double* val)
2476 {
2477 if (PyNumber_Check(obj)) {
2478 if (val) *val = PyFloat_AsDouble(obj);
2479 return 1;
2480 }
2481 else {
2482 SWIG_type_error("number", obj);
2483 }
2484 return 0;
2485 }
2486
2487
2488 SWIGINTERNSHORT double
2489 SWIG_As_double(PyObject* obj)
2490 {
2491 double v;
2492 if (!SWIG_AsVal_double(obj, &v)) {
2493 /*
2494 this is needed to make valgrind/purify happier.
2495 */
2496 memset((void*)&v, 0, sizeof(double));
2497 }
2498 return v;
2499 }
2500
2501
2502 SWIGINTERNSHORT int
2503 SWIG_Check_double(PyObject* obj)
2504 {
2505 return SWIG_AsVal_double(obj, (double*)0);
2506 }
2507
2508 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2509 double rv;
2510 self->Read(key, &rv, defaultVal);
2511 return rv;
2512 }
2513
2514 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2515 #define SWIG_From_double PyFloat_FromDouble
2516 /*@@*/
2517
2518 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2519 bool rv;
2520 self->Read(key, &rv, defaultVal);
2521 return rv;
2522 }
2523
2524 #include <wx/datetime.h>
2525
2526 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2527 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2528
2529 #define LOCAL_TZ wxDateTime::Local
2530
2531 static PyObject *DateTime_GetAmPmStrings(){
2532 wxString am;
2533 wxString pm;
2534 wxDateTime::GetAmPmStrings(&am, &pm);
2535 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2536 PyObject* tup = PyTuple_New(2);
2537 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2538 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2539 wxPyEndBlockThreads(blocked);
2540 return tup;
2541 }
2542
2543 #if UINT_MAX < LONG_MAX
2544 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2545 #define SWIG_From_unsigned_SS_int SWIG_From_long
2546 /*@@*/
2547 #else
2548 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2549 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2550 /*@@*/
2551 #endif
2552
2553 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2554 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2555 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2556 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2557 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2558 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2559 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2560 return (*self < *other);
2561 }
2562 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2563 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2564 return (*self <= *other);
2565 }
2566 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2567 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2568 return (*self > *other);
2569 }
2570 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2571 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2572 return (*self >= *other);
2573 }
2574 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2575 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2576 return (*self == *other);
2577 }
2578 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2579 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2580 return (*self != *other);
2581 }
2582 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2583 const wxChar* rv;
2584 const wxChar* _date = date;
2585 rv = self->ParseRfc822Date(_date);
2586 if (rv == NULL) return -1;
2587 return rv - _date;
2588 }
2589 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2590 const wxChar* rv;
2591 const wxChar* _date = date;
2592 rv = self->ParseFormat(_date, format, dateDef);
2593 if (rv == NULL) return -1;
2594 return rv - _date;
2595 }
2596 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2597 const wxChar* rv;
2598 const wxChar* _datetime = datetime;
2599 rv = self->ParseDateTime(_datetime);
2600 if (rv == NULL) return -1;
2601 return rv - _datetime;
2602 }
2603 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2604 const wxChar* rv;
2605 const wxChar* _date = date;
2606 rv = self->ParseDate(_date);
2607 if (rv == NULL) return -1;
2608 return rv - _date;
2609 }
2610 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2611 const wxChar* rv;
2612 const wxChar* _time = time;
2613 rv = self->ParseTime(_time);
2614 if (rv == NULL) return -1;
2615 return rv - _time;
2616 }
2617 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2618 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2619 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2620 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2621 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2622 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2623 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2624 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2625 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2626 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2627 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2628 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2629 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2630 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2631 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2632 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2633
2634 #include <wx/dataobj.h>
2635
2636 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2637 size_t count = self->GetFormatCount(dir);
2638 wxDataFormat* formats = new wxDataFormat[count];
2639 self->GetAllFormats(formats, dir);
2640
2641 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2642 PyObject* list = PyList_New(count);
2643 for (size_t i=0; i<count; i++) {
2644 wxDataFormat* format = new wxDataFormat(formats[i]);
2645 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2646 PyList_Append(list, obj);
2647 Py_DECREF(obj);
2648 }
2649 wxPyEndBlockThreads(blocked);
2650 delete [] formats;
2651 return list;
2652 }
2653 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2654 PyObject* rval = NULL;
2655 size_t size = self->GetDataSize(format);
2656 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2657 if (size) {
2658 char* buf = new char[size];
2659 if (self->GetDataHere(format, buf))
2660 rval = PyString_FromStringAndSize(buf, size);
2661 delete [] buf;
2662 }
2663 if (! rval) {
2664 rval = Py_None;
2665 Py_INCREF(rval);
2666 }
2667 wxPyEndBlockThreads(blocked);
2668 return rval;
2669 }
2670 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2671 bool rval;
2672 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2673 if (PyString_Check(data)) {
2674 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2675 }
2676 else {
2677 // raise a TypeError if not a string
2678 PyErr_SetString(PyExc_TypeError, "String expected.");
2679 rval = false;
2680 }
2681 wxPyEndBlockThreads(blocked);
2682 return rval;
2683 }
2684 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2685 PyObject* rval = NULL;
2686 size_t size = self->GetDataSize();
2687 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2688 if (size) {
2689 char* buf = new char[size];
2690 if (self->GetDataHere(buf))
2691 rval = PyString_FromStringAndSize(buf, size);
2692 delete [] buf;
2693 }
2694 if (! rval) {
2695 rval = Py_None;
2696 Py_INCREF(rval);
2697 }
2698 wxPyEndBlockThreads(blocked);
2699 return rval;
2700 }
2701 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2702 bool rval;
2703 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2704 if (PyString_Check(data)) {
2705 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2706 }
2707 else {
2708 // raise a TypeError if not a string
2709 PyErr_SetString(PyExc_TypeError, "String expected.");
2710 rval = false;
2711 }
2712 wxPyEndBlockThreads(blocked);
2713 return rval;
2714 }
2715 // Create a new class for wxPython to use
2716 class wxPyDataObjectSimple : public wxDataObjectSimple {
2717 public:
2718 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2719 : wxDataObjectSimple(format) {}
2720
2721 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2722 bool GetDataHere(void *buf) const;
2723 bool SetData(size_t len, const void *buf) const;
2724 PYPRIVATE;
2725 };
2726
2727 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2728
2729 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2730 // We need to get the data for this object and write it to buf. I think
2731 // the best way to do this for wxPython is to have the Python method
2732 // return either a string or None and then act appropriately with the
2733 // C++ version.
2734
2735 bool rval = false;
2736 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2737 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2738 PyObject* ro;
2739 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2740 if (ro) {
2741 rval = (ro != Py_None && PyString_Check(ro));
2742 if (rval)
2743 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2744 Py_DECREF(ro);
2745 }
2746 }
2747 wxPyEndBlockThreads(blocked);
2748 return rval;
2749 }
2750
2751 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2752 // For this one we simply need to make a string from buf and len
2753 // and send it to the Python method.
2754 bool rval = false;
2755 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2756 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2757 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2758 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2759 Py_DECREF(data);
2760 }
2761 wxPyEndBlockThreads(blocked);
2762 return rval;
2763 }
2764
2765 // Create a new class for wxPython to use
2766 class wxPyTextDataObject : public wxTextDataObject {
2767 public:
2768 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2769 : wxTextDataObject(text) {}
2770
2771 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2772 DEC_PYCALLBACK_STRING__const(GetText);
2773 DEC_PYCALLBACK__STRING(SetText);
2774 PYPRIVATE;
2775 };
2776
2777 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2778 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2779 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2780
2781
2782 // Create a new class for wxPython to use
2783 class wxPyBitmapDataObject : public wxBitmapDataObject {
2784 public:
2785 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2786 : wxBitmapDataObject(bitmap) {}
2787
2788 wxBitmap GetBitmap() const;
2789 void SetBitmap(const wxBitmap& bitmap);
2790 PYPRIVATE;
2791 };
2792
2793 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2794 wxBitmap* rval = &wxNullBitmap;
2795 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2796 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2797 PyObject* ro;
2798 wxBitmap* ptr;
2799 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2800 if (ro) {
2801 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2802 rval = ptr;
2803 Py_DECREF(ro);
2804 }
2805 }
2806 wxPyEndBlockThreads(blocked);
2807 return *rval;
2808 }
2809
2810 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2811 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2812 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2813 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2814 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2815 Py_DECREF(bo);
2816 }
2817 wxPyEndBlockThreads(blocked);
2818 }
2819
2820 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2821 return new wxCustomDataObject(wxDataFormat(formatName));
2822 }
2823 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2824 bool rval;
2825 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2826 if (PyString_Check(data)) {
2827 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2828 }
2829 else {
2830 // raise a TypeError if not a string
2831 PyErr_SetString(PyExc_TypeError, "String expected.");
2832 rval = false;
2833 }
2834 wxPyEndBlockThreads(blocked);
2835 return rval;
2836 }
2837 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2838 PyObject* obj;
2839 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2840 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2841 wxPyEndBlockThreads(blocked);
2842 return obj;
2843 }
2844
2845 #include <wx/metafile.h>
2846
2847
2848 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2849
2850
2851 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2852 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2853 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2854 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2855 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2856
2857
2858 class wxPyTextDropTarget : public wxTextDropTarget {
2859 public:
2860 wxPyTextDropTarget() {}
2861
2862 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2863
2864 DEC_PYCALLBACK__(OnLeave);
2865 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2866 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2867 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2868 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2869
2870 PYPRIVATE;
2871 };
2872
2873 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2874 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2875 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2876 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2877 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2878 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2879
2880
2881
2882 class wxPyFileDropTarget : public wxFileDropTarget {
2883 public:
2884 wxPyFileDropTarget() {}
2885
2886 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2887
2888 DEC_PYCALLBACK__(OnLeave);
2889 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2890 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2891 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2892 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2893
2894 PYPRIVATE;
2895 };
2896
2897 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2898 const wxArrayString& filenames) {
2899 bool rval = false;
2900 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2901 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2902 PyObject* list = wxArrayString2PyList_helper(filenames);
2903 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2904 Py_DECREF(list);
2905 }
2906 wxPyEndBlockThreads(blocked);
2907 return rval;
2908 }
2909
2910
2911
2912 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2913 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2914 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2915 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2916 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2917
2918
2919
2920
2921 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2922
2923 #include <wx/display.h>
2924
2925 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2926 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2927
2928 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2929 #if !wxUSE_DISPLAY
2930 #include <wx/dynarray.h>
2931 #include <wx/vidmode.h>
2932
2933 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2934 #include "wx/arrimpl.cpp"
2935 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2936 const wxVideoMode wxDefaultVideoMode;
2937
2938 class wxDisplay
2939 {
2940 public:
2941 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2942 ~wxDisplay() {}
2943
2944 static size_t GetCount()
2945 { wxPyRaiseNotImplemented(); return 0; }
2946
2947 static int GetFromPoint(const wxPoint& pt)
2948 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2949 static int GetFromWindow(wxWindow *window)
2950 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2951
2952 virtual bool IsOk() const { return false; }
2953 virtual wxRect GetGeometry() const { wxRect r; return r; }
2954 virtual wxString GetName() const { return wxEmptyString; }
2955 bool IsPrimary() const { return false; }
2956
2957 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2958 { wxArrayVideoModes a; return a; }
2959
2960 virtual wxVideoMode GetCurrentMode() const
2961 { return wxDefaultVideoMode; }
2962
2963 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2964 { return false; }
2965
2966 void ResetMode() {}
2967 };
2968 #endif
2969
2970 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2971 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2972 PyObject* pyList = NULL;
2973 wxArrayVideoModes arr = self->GetModes(mode);
2974 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2975 pyList = PyList_New(0);
2976 for (int i=0; i < arr.GetCount(); i++) {
2977 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2978 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2979 PyList_Append(pyList, pyObj);
2980 Py_DECREF(pyObj);
2981 }
2982 wxPyEndBlockThreads(blocked);
2983 return pyList;
2984 }
2985
2986 #include <wx/stdpaths.h>
2987
2988 static wxStandardPaths *StandardPaths_Get(){
2989 return (wxStandardPaths*) &wxStandardPaths::Get();
2990 }
2991 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2992 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2993 #ifdef __cplusplus
2994 extern "C" {
2995 #endif
2996 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2997 PyObject *resultobj;
2998 wxSystemColour arg1 ;
2999 wxColour result;
3000 PyObject * obj0 = 0 ;
3001 char *kwnames[] = {
3002 (char *) "index", NULL
3003 };
3004
3005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3006 {
3007 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3008 if (SWIG_arg_fail(1)) SWIG_fail;
3009 }
3010 {
3011 if (!wxPyCheckForApp()) SWIG_fail;
3012 PyThreadState* __tstate = wxPyBeginAllowThreads();
3013 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3014
3015 wxPyEndAllowThreads(__tstate);
3016 if (PyErr_Occurred()) SWIG_fail;
3017 }
3018 {
3019 wxColour * resultptr;
3020 resultptr = new wxColour((wxColour &)(result));
3021 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3022 }
3023 return resultobj;
3024 fail:
3025 return NULL;
3026 }
3027
3028
3029 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3030 PyObject *resultobj;
3031 wxSystemFont arg1 ;
3032 wxFont result;
3033 PyObject * obj0 = 0 ;
3034 char *kwnames[] = {
3035 (char *) "index", NULL
3036 };
3037
3038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3039 {
3040 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3041 if (SWIG_arg_fail(1)) SWIG_fail;
3042 }
3043 {
3044 if (!wxPyCheckForApp()) SWIG_fail;
3045 PyThreadState* __tstate = wxPyBeginAllowThreads();
3046 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3047
3048 wxPyEndAllowThreads(__tstate);
3049 if (PyErr_Occurred()) SWIG_fail;
3050 }
3051 {
3052 wxFont * resultptr;
3053 resultptr = new wxFont((wxFont &)(result));
3054 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3055 }
3056 return resultobj;
3057 fail:
3058 return NULL;
3059 }
3060
3061
3062 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3063 PyObject *resultobj;
3064 wxSystemMetric arg1 ;
3065 wxWindow *arg2 = (wxWindow *) NULL ;
3066 int result;
3067 PyObject * obj0 = 0 ;
3068 PyObject * obj1 = 0 ;
3069 char *kwnames[] = {
3070 (char *) "index",(char *) "win", NULL
3071 };
3072
3073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3074 {
3075 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3076 if (SWIG_arg_fail(1)) SWIG_fail;
3077 }
3078 if (obj1) {
3079 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3080 if (SWIG_arg_fail(2)) SWIG_fail;
3081 }
3082 {
3083 if (!wxPyCheckForApp()) SWIG_fail;
3084 PyThreadState* __tstate = wxPyBeginAllowThreads();
3085 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3086
3087 wxPyEndAllowThreads(__tstate);
3088 if (PyErr_Occurred()) SWIG_fail;
3089 }
3090 {
3091 resultobj = SWIG_From_int((int)(result));
3092 }
3093 return resultobj;
3094 fail:
3095 return NULL;
3096 }
3097
3098
3099 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3100 PyObject *resultobj;
3101 wxSystemFeature arg1 ;
3102 bool result;
3103 PyObject * obj0 = 0 ;
3104 char *kwnames[] = {
3105 (char *) "index", NULL
3106 };
3107
3108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3109 {
3110 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3111 if (SWIG_arg_fail(1)) SWIG_fail;
3112 }
3113 {
3114 if (!wxPyCheckForApp()) SWIG_fail;
3115 PyThreadState* __tstate = wxPyBeginAllowThreads();
3116 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3117
3118 wxPyEndAllowThreads(__tstate);
3119 if (PyErr_Occurred()) SWIG_fail;
3120 }
3121 {
3122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3123 }
3124 return resultobj;
3125 fail:
3126 return NULL;
3127 }
3128
3129
3130 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3131 PyObject *resultobj;
3132 wxSystemScreenType result;
3133 char *kwnames[] = {
3134 NULL
3135 };
3136
3137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3138 {
3139 if (!wxPyCheckForApp()) SWIG_fail;
3140 PyThreadState* __tstate = wxPyBeginAllowThreads();
3141 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3142
3143 wxPyEndAllowThreads(__tstate);
3144 if (PyErr_Occurred()) SWIG_fail;
3145 }
3146 resultobj = SWIG_From_int((result));
3147 return resultobj;
3148 fail:
3149 return NULL;
3150 }
3151
3152
3153 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3154 PyObject *resultobj;
3155 wxSystemScreenType arg1 ;
3156 PyObject * obj0 = 0 ;
3157 char *kwnames[] = {
3158 (char *) "screen", NULL
3159 };
3160
3161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3162 {
3163 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3164 if (SWIG_arg_fail(1)) SWIG_fail;
3165 }
3166 {
3167 if (!wxPyCheckForApp()) SWIG_fail;
3168 PyThreadState* __tstate = wxPyBeginAllowThreads();
3169 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3170
3171 wxPyEndAllowThreads(__tstate);
3172 if (PyErr_Occurred()) SWIG_fail;
3173 }
3174 Py_INCREF(Py_None); resultobj = Py_None;
3175 return resultobj;
3176 fail:
3177 return NULL;
3178 }
3179
3180
3181 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3182 PyObject *obj;
3183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3184 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3185 Py_INCREF(obj);
3186 return Py_BuildValue((char *)"");
3187 }
3188 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3189 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3190 return 1;
3191 }
3192
3193
3194 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3195 PyObject *pyobj;
3196
3197 {
3198 #if wxUSE_UNICODE
3199 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3200 #else
3201 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3202 #endif
3203 }
3204 return pyobj;
3205 }
3206
3207
3208 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3209 PyObject *resultobj;
3210 wxSystemOptions *result;
3211 char *kwnames[] = {
3212 NULL
3213 };
3214
3215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3216 {
3217 PyThreadState* __tstate = wxPyBeginAllowThreads();
3218 result = (wxSystemOptions *)new wxSystemOptions();
3219
3220 wxPyEndAllowThreads(__tstate);
3221 if (PyErr_Occurred()) SWIG_fail;
3222 }
3223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3224 return resultobj;
3225 fail:
3226 return NULL;
3227 }
3228
3229
3230 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3231 PyObject *resultobj;
3232 wxString *arg1 = 0 ;
3233 wxString *arg2 = 0 ;
3234 bool temp1 = false ;
3235 bool temp2 = false ;
3236 PyObject * obj0 = 0 ;
3237 PyObject * obj1 = 0 ;
3238 char *kwnames[] = {
3239 (char *) "name",(char *) "value", NULL
3240 };
3241
3242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3243 {
3244 arg1 = wxString_in_helper(obj0);
3245 if (arg1 == NULL) SWIG_fail;
3246 temp1 = true;
3247 }
3248 {
3249 arg2 = wxString_in_helper(obj1);
3250 if (arg2 == NULL) SWIG_fail;
3251 temp2 = true;
3252 }
3253 {
3254 PyThreadState* __tstate = wxPyBeginAllowThreads();
3255 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3256
3257 wxPyEndAllowThreads(__tstate);
3258 if (PyErr_Occurred()) SWIG_fail;
3259 }
3260 Py_INCREF(Py_None); resultobj = Py_None;
3261 {
3262 if (temp1)
3263 delete arg1;
3264 }
3265 {
3266 if (temp2)
3267 delete arg2;
3268 }
3269 return resultobj;
3270 fail:
3271 {
3272 if (temp1)
3273 delete arg1;
3274 }
3275 {
3276 if (temp2)
3277 delete arg2;
3278 }
3279 return NULL;
3280 }
3281
3282
3283 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3284 PyObject *resultobj;
3285 wxString *arg1 = 0 ;
3286 int arg2 ;
3287 bool temp1 = false ;
3288 PyObject * obj0 = 0 ;
3289 PyObject * obj1 = 0 ;
3290 char *kwnames[] = {
3291 (char *) "name",(char *) "value", NULL
3292 };
3293
3294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3295 {
3296 arg1 = wxString_in_helper(obj0);
3297 if (arg1 == NULL) SWIG_fail;
3298 temp1 = true;
3299 }
3300 {
3301 arg2 = (int)(SWIG_As_int(obj1));
3302 if (SWIG_arg_fail(2)) SWIG_fail;
3303 }
3304 {
3305 PyThreadState* __tstate = wxPyBeginAllowThreads();
3306 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3307
3308 wxPyEndAllowThreads(__tstate);
3309 if (PyErr_Occurred()) SWIG_fail;
3310 }
3311 Py_INCREF(Py_None); resultobj = Py_None;
3312 {
3313 if (temp1)
3314 delete arg1;
3315 }
3316 return resultobj;
3317 fail:
3318 {
3319 if (temp1)
3320 delete arg1;
3321 }
3322 return NULL;
3323 }
3324
3325
3326 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3327 PyObject *resultobj;
3328 wxString *arg1 = 0 ;
3329 wxString result;
3330 bool temp1 = false ;
3331 PyObject * obj0 = 0 ;
3332 char *kwnames[] = {
3333 (char *) "name", NULL
3334 };
3335
3336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3337 {
3338 arg1 = wxString_in_helper(obj0);
3339 if (arg1 == NULL) SWIG_fail;
3340 temp1 = true;
3341 }
3342 {
3343 PyThreadState* __tstate = wxPyBeginAllowThreads();
3344 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3345
3346 wxPyEndAllowThreads(__tstate);
3347 if (PyErr_Occurred()) SWIG_fail;
3348 }
3349 {
3350 #if wxUSE_UNICODE
3351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3352 #else
3353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3354 #endif
3355 }
3356 {
3357 if (temp1)
3358 delete arg1;
3359 }
3360 return resultobj;
3361 fail:
3362 {
3363 if (temp1)
3364 delete arg1;
3365 }
3366 return NULL;
3367 }
3368
3369
3370 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3371 PyObject *resultobj;
3372 wxString *arg1 = 0 ;
3373 int result;
3374 bool temp1 = false ;
3375 PyObject * obj0 = 0 ;
3376 char *kwnames[] = {
3377 (char *) "name", NULL
3378 };
3379
3380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3381 {
3382 arg1 = wxString_in_helper(obj0);
3383 if (arg1 == NULL) SWIG_fail;
3384 temp1 = true;
3385 }
3386 {
3387 PyThreadState* __tstate = wxPyBeginAllowThreads();
3388 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3389
3390 wxPyEndAllowThreads(__tstate);
3391 if (PyErr_Occurred()) SWIG_fail;
3392 }
3393 {
3394 resultobj = SWIG_From_int((int)(result));
3395 }
3396 {
3397 if (temp1)
3398 delete arg1;
3399 }
3400 return resultobj;
3401 fail:
3402 {
3403 if (temp1)
3404 delete arg1;
3405 }
3406 return NULL;
3407 }
3408
3409
3410 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3411 PyObject *resultobj;
3412 wxString *arg1 = 0 ;
3413 bool result;
3414 bool temp1 = false ;
3415 PyObject * obj0 = 0 ;
3416 char *kwnames[] = {
3417 (char *) "name", NULL
3418 };
3419
3420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3421 {
3422 arg1 = wxString_in_helper(obj0);
3423 if (arg1 == NULL) SWIG_fail;
3424 temp1 = true;
3425 }
3426 {
3427 PyThreadState* __tstate = wxPyBeginAllowThreads();
3428 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3429
3430 wxPyEndAllowThreads(__tstate);
3431 if (PyErr_Occurred()) SWIG_fail;
3432 }
3433 {
3434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3435 }
3436 {
3437 if (temp1)
3438 delete arg1;
3439 }
3440 return resultobj;
3441 fail:
3442 {
3443 if (temp1)
3444 delete arg1;
3445 }
3446 return NULL;
3447 }
3448
3449
3450 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3451 PyObject *resultobj;
3452 wxString *arg1 = 0 ;
3453 bool result;
3454 bool temp1 = false ;
3455 PyObject * obj0 = 0 ;
3456 char *kwnames[] = {
3457 (char *) "name", NULL
3458 };
3459
3460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3461 {
3462 arg1 = wxString_in_helper(obj0);
3463 if (arg1 == NULL) SWIG_fail;
3464 temp1 = true;
3465 }
3466 {
3467 PyThreadState* __tstate = wxPyBeginAllowThreads();
3468 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3469
3470 wxPyEndAllowThreads(__tstate);
3471 if (PyErr_Occurred()) SWIG_fail;
3472 }
3473 {
3474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3475 }
3476 {
3477 if (temp1)
3478 delete arg1;
3479 }
3480 return resultobj;
3481 fail:
3482 {
3483 if (temp1)
3484 delete arg1;
3485 }
3486 return NULL;
3487 }
3488
3489
3490 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3491 PyObject *obj;
3492 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3493 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3494 Py_INCREF(obj);
3495 return Py_BuildValue((char *)"");
3496 }
3497 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3498 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3499 return 1;
3500 }
3501
3502
3503 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3504 PyObject *pyobj;
3505
3506 {
3507 #if wxUSE_UNICODE
3508 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3509 #else
3510 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3511 #endif
3512 }
3513 return pyobj;
3514 }
3515
3516
3517 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3518 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3519 return 1;
3520 }
3521
3522
3523 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3524 PyObject *pyobj;
3525
3526 {
3527 #if wxUSE_UNICODE
3528 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3529 #else
3530 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3531 #endif
3532 }
3533 return pyobj;
3534 }
3535
3536
3537 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3538 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3539 return 1;
3540 }
3541
3542
3543 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3544 PyObject *pyobj;
3545
3546 {
3547 #if wxUSE_UNICODE
3548 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3549 #else
3550 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3551 #endif
3552 }
3553 return pyobj;
3554 }
3555
3556
3557 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3558 PyObject *resultobj;
3559 long result;
3560 char *kwnames[] = {
3561 NULL
3562 };
3563
3564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3565 {
3566 PyThreadState* __tstate = wxPyBeginAllowThreads();
3567 result = (long)wxNewId();
3568
3569 wxPyEndAllowThreads(__tstate);
3570 if (PyErr_Occurred()) SWIG_fail;
3571 }
3572 {
3573 resultobj = SWIG_From_long((long)(result));
3574 }
3575 return resultobj;
3576 fail:
3577 return NULL;
3578 }
3579
3580
3581 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3582 PyObject *resultobj;
3583 long arg1 ;
3584 PyObject * obj0 = 0 ;
3585 char *kwnames[] = {
3586 (char *) "id", NULL
3587 };
3588
3589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3590 {
3591 arg1 = (long)(SWIG_As_long(obj0));
3592 if (SWIG_arg_fail(1)) SWIG_fail;
3593 }
3594 {
3595 PyThreadState* __tstate = wxPyBeginAllowThreads();
3596 wxRegisterId(arg1);
3597
3598 wxPyEndAllowThreads(__tstate);
3599 if (PyErr_Occurred()) SWIG_fail;
3600 }
3601 Py_INCREF(Py_None); resultobj = Py_None;
3602 return resultobj;
3603 fail:
3604 return NULL;
3605 }
3606
3607
3608 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3609 PyObject *resultobj;
3610 long result;
3611 char *kwnames[] = {
3612 NULL
3613 };
3614
3615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3616 {
3617 PyThreadState* __tstate = wxPyBeginAllowThreads();
3618 result = (long)wxGetCurrentId();
3619
3620 wxPyEndAllowThreads(__tstate);
3621 if (PyErr_Occurred()) SWIG_fail;
3622 }
3623 {
3624 resultobj = SWIG_From_long((long)(result));
3625 }
3626 return resultobj;
3627 fail:
3628 return NULL;
3629 }
3630
3631
3632 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3633 PyObject *resultobj;
3634 int arg1 ;
3635 bool result;
3636 PyObject * obj0 = 0 ;
3637 char *kwnames[] = {
3638 (char *) "id", NULL
3639 };
3640
3641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3642 {
3643 arg1 = (int)(SWIG_As_int(obj0));
3644 if (SWIG_arg_fail(1)) SWIG_fail;
3645 }
3646 {
3647 PyThreadState* __tstate = wxPyBeginAllowThreads();
3648 result = (bool)wxIsStockID(arg1);
3649
3650 wxPyEndAllowThreads(__tstate);
3651 if (PyErr_Occurred()) SWIG_fail;
3652 }
3653 {
3654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3655 }
3656 return resultobj;
3657 fail:
3658 return NULL;
3659 }
3660
3661
3662 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3663 PyObject *resultobj;
3664 int arg1 ;
3665 wxString *arg2 = 0 ;
3666 bool result;
3667 bool temp2 = false ;
3668 PyObject * obj0 = 0 ;
3669 PyObject * obj1 = 0 ;
3670 char *kwnames[] = {
3671 (char *) "id",(char *) "label", NULL
3672 };
3673
3674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3675 {
3676 arg1 = (int)(SWIG_As_int(obj0));
3677 if (SWIG_arg_fail(1)) SWIG_fail;
3678 }
3679 {
3680 arg2 = wxString_in_helper(obj1);
3681 if (arg2 == NULL) SWIG_fail;
3682 temp2 = true;
3683 }
3684 {
3685 PyThreadState* __tstate = wxPyBeginAllowThreads();
3686 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3687
3688 wxPyEndAllowThreads(__tstate);
3689 if (PyErr_Occurred()) SWIG_fail;
3690 }
3691 {
3692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3693 }
3694 {
3695 if (temp2)
3696 delete arg2;
3697 }
3698 return resultobj;
3699 fail:
3700 {
3701 if (temp2)
3702 delete arg2;
3703 }
3704 return NULL;
3705 }
3706
3707
3708 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3709 PyObject *resultobj;
3710 int arg1 ;
3711 bool arg2 = (bool) true ;
3712 wxString arg3 = (wxString) wxPyEmptyString ;
3713 wxString result;
3714 PyObject * obj0 = 0 ;
3715 PyObject * obj1 = 0 ;
3716 PyObject * obj2 = 0 ;
3717 char *kwnames[] = {
3718 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3719 };
3720
3721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3722 {
3723 arg1 = (int)(SWIG_As_int(obj0));
3724 if (SWIG_arg_fail(1)) SWIG_fail;
3725 }
3726 if (obj1) {
3727 {
3728 arg2 = (bool)(SWIG_As_bool(obj1));
3729 if (SWIG_arg_fail(2)) SWIG_fail;
3730 }
3731 }
3732 if (obj2) {
3733 {
3734 wxString* sptr = wxString_in_helper(obj2);
3735 if (sptr == NULL) SWIG_fail;
3736 arg3 = *sptr;
3737 delete sptr;
3738 }
3739 }
3740 {
3741 PyThreadState* __tstate = wxPyBeginAllowThreads();
3742 result = wxGetStockLabel(arg1,arg2,arg3);
3743
3744 wxPyEndAllowThreads(__tstate);
3745 if (PyErr_Occurred()) SWIG_fail;
3746 }
3747 {
3748 #if wxUSE_UNICODE
3749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3750 #else
3751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3752 #endif
3753 }
3754 return resultobj;
3755 fail:
3756 return NULL;
3757 }
3758
3759
3760 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3761 PyObject *resultobj;
3762 char *kwnames[] = {
3763 NULL
3764 };
3765
3766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3767 {
3768 if (!wxPyCheckForApp()) SWIG_fail;
3769 PyThreadState* __tstate = wxPyBeginAllowThreads();
3770 wxBell();
3771
3772 wxPyEndAllowThreads(__tstate);
3773 if (PyErr_Occurred()) SWIG_fail;
3774 }
3775 Py_INCREF(Py_None); resultobj = Py_None;
3776 return resultobj;
3777 fail:
3778 return NULL;
3779 }
3780
3781
3782 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3783 PyObject *resultobj;
3784 char *kwnames[] = {
3785 NULL
3786 };
3787
3788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3789 {
3790 if (!wxPyCheckForApp()) SWIG_fail;
3791 PyThreadState* __tstate = wxPyBeginAllowThreads();
3792 wxEndBusyCursor();
3793
3794 wxPyEndAllowThreads(__tstate);
3795 if (PyErr_Occurred()) SWIG_fail;
3796 }
3797 Py_INCREF(Py_None); resultobj = Py_None;
3798 return resultobj;
3799 fail:
3800 return NULL;
3801 }
3802
3803
3804 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3805 PyObject *resultobj;
3806 bool arg1 = (bool) true ;
3807 long result;
3808 PyObject * obj0 = 0 ;
3809 char *kwnames[] = {
3810 (char *) "resetTimer", NULL
3811 };
3812
3813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3814 if (obj0) {
3815 {
3816 arg1 = (bool)(SWIG_As_bool(obj0));
3817 if (SWIG_arg_fail(1)) SWIG_fail;
3818 }
3819 }
3820 {
3821 PyThreadState* __tstate = wxPyBeginAllowThreads();
3822 result = (long)wxGetElapsedTime(arg1);
3823
3824 wxPyEndAllowThreads(__tstate);
3825 if (PyErr_Occurred()) SWIG_fail;
3826 }
3827 {
3828 resultobj = SWIG_From_long((long)(result));
3829 }
3830 return resultobj;
3831 fail:
3832 return NULL;
3833 }
3834
3835
3836 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3837 PyObject *resultobj;
3838 int *arg1 = (int *) 0 ;
3839 int *arg2 = (int *) 0 ;
3840 int temp1 ;
3841 int res1 = 0 ;
3842 int temp2 ;
3843 int res2 = 0 ;
3844 char *kwnames[] = {
3845 NULL
3846 };
3847
3848 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3849 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3851 {
3852 if (!wxPyCheckForApp()) SWIG_fail;
3853 PyThreadState* __tstate = wxPyBeginAllowThreads();
3854 wxGetMousePosition(arg1,arg2);
3855
3856 wxPyEndAllowThreads(__tstate);
3857 if (PyErr_Occurred()) SWIG_fail;
3858 }
3859 Py_INCREF(Py_None); resultobj = Py_None;
3860 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3861 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3862 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3863 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3864 return resultobj;
3865 fail:
3866 return NULL;
3867 }
3868
3869
3870 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3871 PyObject *resultobj;
3872 bool result;
3873 char *kwnames[] = {
3874 NULL
3875 };
3876
3877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3878 {
3879 PyThreadState* __tstate = wxPyBeginAllowThreads();
3880 result = (bool)wxIsBusy();
3881
3882 wxPyEndAllowThreads(__tstate);
3883 if (PyErr_Occurred()) SWIG_fail;
3884 }
3885 {
3886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3887 }
3888 return resultobj;
3889 fail:
3890 return NULL;
3891 }
3892
3893
3894 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3895 PyObject *resultobj;
3896 wxString result;
3897 char *kwnames[] = {
3898 NULL
3899 };
3900
3901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3902 {
3903 PyThreadState* __tstate = wxPyBeginAllowThreads();
3904 result = wxNow();
3905
3906 wxPyEndAllowThreads(__tstate);
3907 if (PyErr_Occurred()) SWIG_fail;
3908 }
3909 {
3910 #if wxUSE_UNICODE
3911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3912 #else
3913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3914 #endif
3915 }
3916 return resultobj;
3917 fail:
3918 return NULL;
3919 }
3920
3921
3922 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3923 PyObject *resultobj;
3924 wxString const &arg1_defvalue = wxPyEmptyString ;
3925 wxString *arg1 = (wxString *) &arg1_defvalue ;
3926 bool result;
3927 bool temp1 = false ;
3928 PyObject * obj0 = 0 ;
3929 char *kwnames[] = {
3930 (char *) "command", NULL
3931 };
3932
3933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3934 if (obj0) {
3935 {
3936 arg1 = wxString_in_helper(obj0);
3937 if (arg1 == NULL) SWIG_fail;
3938 temp1 = true;
3939 }
3940 }
3941 {
3942 PyThreadState* __tstate = wxPyBeginAllowThreads();
3943 result = (bool)wxShell((wxString const &)*arg1);
3944
3945 wxPyEndAllowThreads(__tstate);
3946 if (PyErr_Occurred()) SWIG_fail;
3947 }
3948 {
3949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3950 }
3951 {
3952 if (temp1)
3953 delete arg1;
3954 }
3955 return resultobj;
3956 fail:
3957 {
3958 if (temp1)
3959 delete arg1;
3960 }
3961 return NULL;
3962 }
3963
3964
3965 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3966 PyObject *resultobj;
3967 char *kwnames[] = {
3968 NULL
3969 };
3970
3971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3972 {
3973 PyThreadState* __tstate = wxPyBeginAllowThreads();
3974 wxStartTimer();
3975
3976 wxPyEndAllowThreads(__tstate);
3977 if (PyErr_Occurred()) SWIG_fail;
3978 }
3979 Py_INCREF(Py_None); resultobj = Py_None;
3980 return resultobj;
3981 fail:
3982 return NULL;
3983 }
3984
3985
3986 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3987 PyObject *resultobj;
3988 int *arg1 = (int *) 0 ;
3989 int *arg2 = (int *) 0 ;
3990 int result;
3991 int temp1 ;
3992 int res1 = 0 ;
3993 int temp2 ;
3994 int res2 = 0 ;
3995 char *kwnames[] = {
3996 NULL
3997 };
3998
3999 arg1 = &temp1; res1 = SWIG_NEWOBJ;
4000 arg2 = &temp2; res2 = SWIG_NEWOBJ;
4001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
4002 {
4003 PyThreadState* __tstate = wxPyBeginAllowThreads();
4004 result = (int)wxGetOsVersion(arg1,arg2);
4005
4006 wxPyEndAllowThreads(__tstate);
4007 if (PyErr_Occurred()) SWIG_fail;
4008 }
4009 {
4010 resultobj = SWIG_From_int((int)(result));
4011 }
4012 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4013 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4014 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4015 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4016 return resultobj;
4017 fail:
4018 return NULL;
4019 }
4020
4021
4022 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4023 PyObject *resultobj;
4024 wxString result;
4025 char *kwnames[] = {
4026 NULL
4027 };
4028
4029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4030 {
4031 PyThreadState* __tstate = wxPyBeginAllowThreads();
4032 result = wxGetOsDescription();
4033
4034 wxPyEndAllowThreads(__tstate);
4035 if (PyErr_Occurred()) SWIG_fail;
4036 }
4037 {
4038 #if wxUSE_UNICODE
4039 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4040 #else
4041 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4042 #endif
4043 }
4044 return resultobj;
4045 fail:
4046 return NULL;
4047 }
4048
4049
4050 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4051 PyObject *resultobj;
4052 long result;
4053 char *kwnames[] = {
4054 NULL
4055 };
4056
4057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4058 {
4059 PyThreadState* __tstate = wxPyBeginAllowThreads();
4060 result = (long)wxGetFreeMemory();
4061
4062 wxPyEndAllowThreads(__tstate);
4063 if (PyErr_Occurred()) SWIG_fail;
4064 }
4065 {
4066 resultobj = SWIG_From_long((long)(result));
4067 }
4068 return resultobj;
4069 fail:
4070 return NULL;
4071 }
4072
4073
4074 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4075 PyObject *resultobj;
4076 wxShutdownFlags arg1 ;
4077 bool result;
4078 PyObject * obj0 = 0 ;
4079 char *kwnames[] = {
4080 (char *) "wFlags", NULL
4081 };
4082
4083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4084 {
4085 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4086 if (SWIG_arg_fail(1)) SWIG_fail;
4087 }
4088 {
4089 if (!wxPyCheckForApp()) SWIG_fail;
4090 PyThreadState* __tstate = wxPyBeginAllowThreads();
4091 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4092
4093 wxPyEndAllowThreads(__tstate);
4094 if (PyErr_Occurred()) SWIG_fail;
4095 }
4096 {
4097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4098 }
4099 return resultobj;
4100 fail:
4101 return NULL;
4102 }
4103
4104
4105 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4106 PyObject *resultobj;
4107 int arg1 ;
4108 PyObject * obj0 = 0 ;
4109 char *kwnames[] = {
4110 (char *) "secs", NULL
4111 };
4112
4113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4114 {
4115 arg1 = (int)(SWIG_As_int(obj0));
4116 if (SWIG_arg_fail(1)) SWIG_fail;
4117 }
4118 {
4119 PyThreadState* __tstate = wxPyBeginAllowThreads();
4120 wxSleep(arg1);
4121
4122 wxPyEndAllowThreads(__tstate);
4123 if (PyErr_Occurred()) SWIG_fail;
4124 }
4125 Py_INCREF(Py_None); resultobj = Py_None;
4126 return resultobj;
4127 fail:
4128 return NULL;
4129 }
4130
4131
4132 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4133 PyObject *resultobj;
4134 unsigned long arg1 ;
4135 PyObject * obj0 = 0 ;
4136 char *kwnames[] = {
4137 (char *) "milliseconds", NULL
4138 };
4139
4140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4141 {
4142 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4143 if (SWIG_arg_fail(1)) SWIG_fail;
4144 }
4145 {
4146 PyThreadState* __tstate = wxPyBeginAllowThreads();
4147 wxMilliSleep(arg1);
4148
4149 wxPyEndAllowThreads(__tstate);
4150 if (PyErr_Occurred()) SWIG_fail;
4151 }
4152 Py_INCREF(Py_None); resultobj = Py_None;
4153 return resultobj;
4154 fail:
4155 return NULL;
4156 }
4157
4158
4159 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4160 PyObject *resultobj;
4161 unsigned long arg1 ;
4162 PyObject * obj0 = 0 ;
4163 char *kwnames[] = {
4164 (char *) "microseconds", NULL
4165 };
4166
4167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4168 {
4169 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4170 if (SWIG_arg_fail(1)) SWIG_fail;
4171 }
4172 {
4173 PyThreadState* __tstate = wxPyBeginAllowThreads();
4174 wxMicroSleep(arg1);
4175
4176 wxPyEndAllowThreads(__tstate);
4177 if (PyErr_Occurred()) SWIG_fail;
4178 }
4179 Py_INCREF(Py_None); resultobj = Py_None;
4180 return resultobj;
4181 fail:
4182 return NULL;
4183 }
4184
4185
4186 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4187 PyObject *resultobj;
4188 bool arg1 ;
4189 PyObject * obj0 = 0 ;
4190 char *kwnames[] = {
4191 (char *) "enable", NULL
4192 };
4193
4194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4195 {
4196 arg1 = (bool)(SWIG_As_bool(obj0));
4197 if (SWIG_arg_fail(1)) SWIG_fail;
4198 }
4199 {
4200 PyThreadState* __tstate = wxPyBeginAllowThreads();
4201 wxEnableTopLevelWindows(arg1);
4202
4203 wxPyEndAllowThreads(__tstate);
4204 if (PyErr_Occurred()) SWIG_fail;
4205 }
4206 Py_INCREF(Py_None); resultobj = Py_None;
4207 return resultobj;
4208 fail:
4209 return NULL;
4210 }
4211
4212
4213 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4214 PyObject *resultobj;
4215 wxString *arg1 = 0 ;
4216 wxString result;
4217 bool temp1 = false ;
4218 PyObject * obj0 = 0 ;
4219 char *kwnames[] = {
4220 (char *) "in", NULL
4221 };
4222
4223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4224 {
4225 arg1 = wxString_in_helper(obj0);
4226 if (arg1 == NULL) SWIG_fail;
4227 temp1 = true;
4228 }
4229 {
4230 PyThreadState* __tstate = wxPyBeginAllowThreads();
4231 result = wxStripMenuCodes((wxString const &)*arg1);
4232
4233 wxPyEndAllowThreads(__tstate);
4234 if (PyErr_Occurred()) SWIG_fail;
4235 }
4236 {
4237 #if wxUSE_UNICODE
4238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4239 #else
4240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4241 #endif
4242 }
4243 {
4244 if (temp1)
4245 delete arg1;
4246 }
4247 return resultobj;
4248 fail:
4249 {
4250 if (temp1)
4251 delete arg1;
4252 }
4253 return NULL;
4254 }
4255
4256
4257 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4258 PyObject *resultobj;
4259 wxString result;
4260 char *kwnames[] = {
4261 NULL
4262 };
4263
4264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4265 {
4266 PyThreadState* __tstate = wxPyBeginAllowThreads();
4267 result = wxGetEmailAddress();
4268
4269 wxPyEndAllowThreads(__tstate);
4270 if (PyErr_Occurred()) SWIG_fail;
4271 }
4272 {
4273 #if wxUSE_UNICODE
4274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4275 #else
4276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4277 #endif
4278 }
4279 return resultobj;
4280 fail:
4281 return NULL;
4282 }
4283
4284
4285 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4286 PyObject *resultobj;
4287 wxString result;
4288 char *kwnames[] = {
4289 NULL
4290 };
4291
4292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4293 {
4294 PyThreadState* __tstate = wxPyBeginAllowThreads();
4295 result = wxGetHostName();
4296
4297 wxPyEndAllowThreads(__tstate);
4298 if (PyErr_Occurred()) SWIG_fail;
4299 }
4300 {
4301 #if wxUSE_UNICODE
4302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4303 #else
4304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4305 #endif
4306 }
4307 return resultobj;
4308 fail:
4309 return NULL;
4310 }
4311
4312
4313 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4314 PyObject *resultobj;
4315 wxString result;
4316 char *kwnames[] = {
4317 NULL
4318 };
4319
4320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4321 {
4322 PyThreadState* __tstate = wxPyBeginAllowThreads();
4323 result = wxGetFullHostName();
4324
4325 wxPyEndAllowThreads(__tstate);
4326 if (PyErr_Occurred()) SWIG_fail;
4327 }
4328 {
4329 #if wxUSE_UNICODE
4330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4331 #else
4332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4333 #endif
4334 }
4335 return resultobj;
4336 fail:
4337 return NULL;
4338 }
4339
4340
4341 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4342 PyObject *resultobj;
4343 wxString result;
4344 char *kwnames[] = {
4345 NULL
4346 };
4347
4348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4349 {
4350 PyThreadState* __tstate = wxPyBeginAllowThreads();
4351 result = wxGetUserId();
4352
4353 wxPyEndAllowThreads(__tstate);
4354 if (PyErr_Occurred()) SWIG_fail;
4355 }
4356 {
4357 #if wxUSE_UNICODE
4358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4359 #else
4360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4361 #endif
4362 }
4363 return resultobj;
4364 fail:
4365 return NULL;
4366 }
4367
4368
4369 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4370 PyObject *resultobj;
4371 wxString result;
4372 char *kwnames[] = {
4373 NULL
4374 };
4375
4376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4377 {
4378 PyThreadState* __tstate = wxPyBeginAllowThreads();
4379 result = wxGetUserName();
4380
4381 wxPyEndAllowThreads(__tstate);
4382 if (PyErr_Occurred()) SWIG_fail;
4383 }
4384 {
4385 #if wxUSE_UNICODE
4386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4387 #else
4388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4389 #endif
4390 }
4391 return resultobj;
4392 fail:
4393 return NULL;
4394 }
4395
4396
4397 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4398 PyObject *resultobj;
4399 wxString result;
4400 char *kwnames[] = {
4401 NULL
4402 };
4403
4404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4405 {
4406 PyThreadState* __tstate = wxPyBeginAllowThreads();
4407 result = wxGetHomeDir();
4408
4409 wxPyEndAllowThreads(__tstate);
4410 if (PyErr_Occurred()) SWIG_fail;
4411 }
4412 {
4413 #if wxUSE_UNICODE
4414 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4415 #else
4416 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4417 #endif
4418 }
4419 return resultobj;
4420 fail:
4421 return NULL;
4422 }
4423
4424
4425 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4426 PyObject *resultobj;
4427 wxString const &arg1_defvalue = wxPyEmptyString ;
4428 wxString *arg1 = (wxString *) &arg1_defvalue ;
4429 wxString result;
4430 bool temp1 = false ;
4431 PyObject * obj0 = 0 ;
4432 char *kwnames[] = {
4433 (char *) "user", NULL
4434 };
4435
4436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4437 if (obj0) {
4438 {
4439 arg1 = wxString_in_helper(obj0);
4440 if (arg1 == NULL) SWIG_fail;
4441 temp1 = true;
4442 }
4443 }
4444 {
4445 PyThreadState* __tstate = wxPyBeginAllowThreads();
4446 result = wxGetUserHome((wxString const &)*arg1);
4447
4448 wxPyEndAllowThreads(__tstate);
4449 if (PyErr_Occurred()) SWIG_fail;
4450 }
4451 {
4452 #if wxUSE_UNICODE
4453 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4454 #else
4455 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4456 #endif
4457 }
4458 {
4459 if (temp1)
4460 delete arg1;
4461 }
4462 return resultobj;
4463 fail:
4464 {
4465 if (temp1)
4466 delete arg1;
4467 }
4468 return NULL;
4469 }
4470
4471
4472 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4473 PyObject *resultobj;
4474 unsigned long result;
4475 char *kwnames[] = {
4476 NULL
4477 };
4478
4479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4480 {
4481 PyThreadState* __tstate = wxPyBeginAllowThreads();
4482 result = (unsigned long)wxGetProcessId();
4483
4484 wxPyEndAllowThreads(__tstate);
4485 if (PyErr_Occurred()) SWIG_fail;
4486 }
4487 {
4488 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4489 }
4490 return resultobj;
4491 fail:
4492 return NULL;
4493 }
4494
4495
4496 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4497 PyObject *resultobj;
4498 char *kwnames[] = {
4499 NULL
4500 };
4501
4502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4503 {
4504 PyThreadState* __tstate = wxPyBeginAllowThreads();
4505 wxTrap();
4506
4507 wxPyEndAllowThreads(__tstate);
4508 if (PyErr_Occurred()) SWIG_fail;
4509 }
4510 Py_INCREF(Py_None); resultobj = Py_None;
4511 return resultobj;
4512 fail:
4513 return NULL;
4514 }
4515
4516
4517 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4518 PyObject *resultobj;
4519 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4520 wxString *arg1 = (wxString *) &arg1_defvalue ;
4521 wxString const &arg2_defvalue = wxPyEmptyString ;
4522 wxString *arg2 = (wxString *) &arg2_defvalue ;
4523 wxString const &arg3_defvalue = wxPyEmptyString ;
4524 wxString *arg3 = (wxString *) &arg3_defvalue ;
4525 wxString const &arg4_defvalue = wxPyEmptyString ;
4526 wxString *arg4 = (wxString *) &arg4_defvalue ;
4527 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4528 wxString *arg5 = (wxString *) &arg5_defvalue ;
4529 int arg6 = (int) 0 ;
4530 wxWindow *arg7 = (wxWindow *) NULL ;
4531 int arg8 = (int) -1 ;
4532 int arg9 = (int) -1 ;
4533 wxString result;
4534 bool temp1 = false ;
4535 bool temp2 = false ;
4536 bool temp3 = false ;
4537 bool temp4 = false ;
4538 bool temp5 = false ;
4539 PyObject * obj0 = 0 ;
4540 PyObject * obj1 = 0 ;
4541 PyObject * obj2 = 0 ;
4542 PyObject * obj3 = 0 ;
4543 PyObject * obj4 = 0 ;
4544 PyObject * obj5 = 0 ;
4545 PyObject * obj6 = 0 ;
4546 PyObject * obj7 = 0 ;
4547 PyObject * obj8 = 0 ;
4548 char *kwnames[] = {
4549 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4550 };
4551
4552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4553 if (obj0) {
4554 {
4555 arg1 = wxString_in_helper(obj0);
4556 if (arg1 == NULL) SWIG_fail;
4557 temp1 = true;
4558 }
4559 }
4560 if (obj1) {
4561 {
4562 arg2 = wxString_in_helper(obj1);
4563 if (arg2 == NULL) SWIG_fail;
4564 temp2 = true;
4565 }
4566 }
4567 if (obj2) {
4568 {
4569 arg3 = wxString_in_helper(obj2);
4570 if (arg3 == NULL) SWIG_fail;
4571 temp3 = true;
4572 }
4573 }
4574 if (obj3) {
4575 {
4576 arg4 = wxString_in_helper(obj3);
4577 if (arg4 == NULL) SWIG_fail;
4578 temp4 = true;
4579 }
4580 }
4581 if (obj4) {
4582 {
4583 arg5 = wxString_in_helper(obj4);
4584 if (arg5 == NULL) SWIG_fail;
4585 temp5 = true;
4586 }
4587 }
4588 if (obj5) {
4589 {
4590 arg6 = (int)(SWIG_As_int(obj5));
4591 if (SWIG_arg_fail(6)) SWIG_fail;
4592 }
4593 }
4594 if (obj6) {
4595 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4596 if (SWIG_arg_fail(7)) SWIG_fail;
4597 }
4598 if (obj7) {
4599 {
4600 arg8 = (int)(SWIG_As_int(obj7));
4601 if (SWIG_arg_fail(8)) SWIG_fail;
4602 }
4603 }
4604 if (obj8) {
4605 {
4606 arg9 = (int)(SWIG_As_int(obj8));
4607 if (SWIG_arg_fail(9)) SWIG_fail;
4608 }
4609 }
4610 {
4611 if (!wxPyCheckForApp()) SWIG_fail;
4612 PyThreadState* __tstate = wxPyBeginAllowThreads();
4613 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4614
4615 wxPyEndAllowThreads(__tstate);
4616 if (PyErr_Occurred()) SWIG_fail;
4617 }
4618 {
4619 #if wxUSE_UNICODE
4620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4621 #else
4622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4623 #endif
4624 }
4625 {
4626 if (temp1)
4627 delete arg1;
4628 }
4629 {
4630 if (temp2)
4631 delete arg2;
4632 }
4633 {
4634 if (temp3)
4635 delete arg3;
4636 }
4637 {
4638 if (temp4)
4639 delete arg4;
4640 }
4641 {
4642 if (temp5)
4643 delete arg5;
4644 }
4645 return resultobj;
4646 fail:
4647 {
4648 if (temp1)
4649 delete arg1;
4650 }
4651 {
4652 if (temp2)
4653 delete arg2;
4654 }
4655 {
4656 if (temp3)
4657 delete arg3;
4658 }
4659 {
4660 if (temp4)
4661 delete arg4;
4662 }
4663 {
4664 if (temp5)
4665 delete arg5;
4666 }
4667 return NULL;
4668 }
4669
4670
4671 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4672 PyObject *resultobj;
4673 wxString *arg1 = 0 ;
4674 wxString *arg2 = 0 ;
4675 wxString const &arg3_defvalue = wxPyEmptyString ;
4676 wxString *arg3 = (wxString *) &arg3_defvalue ;
4677 wxWindow *arg4 = (wxWindow *) NULL ;
4678 wxString result;
4679 bool temp1 = false ;
4680 bool temp2 = false ;
4681 bool temp3 = false ;
4682 PyObject * obj0 = 0 ;
4683 PyObject * obj1 = 0 ;
4684 PyObject * obj2 = 0 ;
4685 PyObject * obj3 = 0 ;
4686 char *kwnames[] = {
4687 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4688 };
4689
4690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4691 {
4692 arg1 = wxString_in_helper(obj0);
4693 if (arg1 == NULL) SWIG_fail;
4694 temp1 = true;
4695 }
4696 {
4697 arg2 = wxString_in_helper(obj1);
4698 if (arg2 == NULL) SWIG_fail;
4699 temp2 = true;
4700 }
4701 if (obj2) {
4702 {
4703 arg3 = wxString_in_helper(obj2);
4704 if (arg3 == NULL) SWIG_fail;
4705 temp3 = true;
4706 }
4707 }
4708 if (obj3) {
4709 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4710 if (SWIG_arg_fail(4)) SWIG_fail;
4711 }
4712 {
4713 if (!wxPyCheckForApp()) SWIG_fail;
4714 PyThreadState* __tstate = wxPyBeginAllowThreads();
4715 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4716
4717 wxPyEndAllowThreads(__tstate);
4718 if (PyErr_Occurred()) SWIG_fail;
4719 }
4720 {
4721 #if wxUSE_UNICODE
4722 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4723 #else
4724 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4725 #endif
4726 }
4727 {
4728 if (temp1)
4729 delete arg1;
4730 }
4731 {
4732 if (temp2)
4733 delete arg2;
4734 }
4735 {
4736 if (temp3)
4737 delete arg3;
4738 }
4739 return resultobj;
4740 fail:
4741 {
4742 if (temp1)
4743 delete arg1;
4744 }
4745 {
4746 if (temp2)
4747 delete arg2;
4748 }
4749 {
4750 if (temp3)
4751 delete arg3;
4752 }
4753 return NULL;
4754 }
4755
4756
4757 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4758 PyObject *resultobj;
4759 wxString *arg1 = 0 ;
4760 wxString *arg2 = 0 ;
4761 wxString const &arg3_defvalue = wxPyEmptyString ;
4762 wxString *arg3 = (wxString *) &arg3_defvalue ;
4763 wxWindow *arg4 = (wxWindow *) NULL ;
4764 wxString result;
4765 bool temp1 = false ;
4766 bool temp2 = false ;
4767 bool temp3 = false ;
4768 PyObject * obj0 = 0 ;
4769 PyObject * obj1 = 0 ;
4770 PyObject * obj2 = 0 ;
4771 PyObject * obj3 = 0 ;
4772 char *kwnames[] = {
4773 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4774 };
4775
4776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4777 {
4778 arg1 = wxString_in_helper(obj0);
4779 if (arg1 == NULL) SWIG_fail;
4780 temp1 = true;
4781 }
4782 {
4783 arg2 = wxString_in_helper(obj1);
4784 if (arg2 == NULL) SWIG_fail;
4785 temp2 = true;
4786 }
4787 if (obj2) {
4788 {
4789 arg3 = wxString_in_helper(obj2);
4790 if (arg3 == NULL) SWIG_fail;
4791 temp3 = true;
4792 }
4793 }
4794 if (obj3) {
4795 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4796 if (SWIG_arg_fail(4)) SWIG_fail;
4797 }
4798 {
4799 if (!wxPyCheckForApp()) SWIG_fail;
4800 PyThreadState* __tstate = wxPyBeginAllowThreads();
4801 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4802
4803 wxPyEndAllowThreads(__tstate);
4804 if (PyErr_Occurred()) SWIG_fail;
4805 }
4806 {
4807 #if wxUSE_UNICODE
4808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4809 #else
4810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4811 #endif
4812 }
4813 {
4814 if (temp1)
4815 delete arg1;
4816 }
4817 {
4818 if (temp2)
4819 delete arg2;
4820 }
4821 {
4822 if (temp3)
4823 delete arg3;
4824 }
4825 return resultobj;
4826 fail:
4827 {
4828 if (temp1)
4829 delete arg1;
4830 }
4831 {
4832 if (temp2)
4833 delete arg2;
4834 }
4835 {
4836 if (temp3)
4837 delete arg3;
4838 }
4839 return NULL;
4840 }
4841
4842
4843 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4844 PyObject *resultobj;
4845 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4846 wxString *arg1 = (wxString *) &arg1_defvalue ;
4847 wxString const &arg2_defvalue = wxPyEmptyString ;
4848 wxString *arg2 = (wxString *) &arg2_defvalue ;
4849 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4850 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4851 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4852 wxWindow *arg5 = (wxWindow *) NULL ;
4853 wxString result;
4854 bool temp1 = false ;
4855 bool temp2 = false ;
4856 wxPoint temp4 ;
4857 PyObject * obj0 = 0 ;
4858 PyObject * obj1 = 0 ;
4859 PyObject * obj2 = 0 ;
4860 PyObject * obj3 = 0 ;
4861 PyObject * obj4 = 0 ;
4862 char *kwnames[] = {
4863 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4864 };
4865
4866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4867 if (obj0) {
4868 {
4869 arg1 = wxString_in_helper(obj0);
4870 if (arg1 == NULL) SWIG_fail;
4871 temp1 = true;
4872 }
4873 }
4874 if (obj1) {
4875 {
4876 arg2 = wxString_in_helper(obj1);
4877 if (arg2 == NULL) SWIG_fail;
4878 temp2 = true;
4879 }
4880 }
4881 if (obj2) {
4882 {
4883 arg3 = (long)(SWIG_As_long(obj2));
4884 if (SWIG_arg_fail(3)) SWIG_fail;
4885 }
4886 }
4887 if (obj3) {
4888 {
4889 arg4 = &temp4;
4890 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4891 }
4892 }
4893 if (obj4) {
4894 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4895 if (SWIG_arg_fail(5)) SWIG_fail;
4896 }
4897 {
4898 if (!wxPyCheckForApp()) SWIG_fail;
4899 PyThreadState* __tstate = wxPyBeginAllowThreads();
4900 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4901
4902 wxPyEndAllowThreads(__tstate);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 {
4906 #if wxUSE_UNICODE
4907 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4908 #else
4909 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4910 #endif
4911 }
4912 {
4913 if (temp1)
4914 delete arg1;
4915 }
4916 {
4917 if (temp2)
4918 delete arg2;
4919 }
4920 return resultobj;
4921 fail:
4922 {
4923 if (temp1)
4924 delete arg1;
4925 }
4926 {
4927 if (temp2)
4928 delete arg2;
4929 }
4930 return NULL;
4931 }
4932
4933
4934 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4935 PyObject *resultobj;
4936 wxString *arg1 = 0 ;
4937 wxString const &arg2_defvalue = wxPyEmptyString ;
4938 wxString *arg2 = (wxString *) &arg2_defvalue ;
4939 wxString const &arg3_defvalue = wxPyEmptyString ;
4940 wxString *arg3 = (wxString *) &arg3_defvalue ;
4941 wxWindow *arg4 = (wxWindow *) NULL ;
4942 int arg5 = (int) -1 ;
4943 int arg6 = (int) -1 ;
4944 bool arg7 = (bool) true ;
4945 wxString result;
4946 bool temp1 = false ;
4947 bool temp2 = false ;
4948 bool temp3 = false ;
4949 PyObject * obj0 = 0 ;
4950 PyObject * obj1 = 0 ;
4951 PyObject * obj2 = 0 ;
4952 PyObject * obj3 = 0 ;
4953 PyObject * obj4 = 0 ;
4954 PyObject * obj5 = 0 ;
4955 PyObject * obj6 = 0 ;
4956 char *kwnames[] = {
4957 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4958 };
4959
4960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4961 {
4962 arg1 = wxString_in_helper(obj0);
4963 if (arg1 == NULL) SWIG_fail;
4964 temp1 = true;
4965 }
4966 if (obj1) {
4967 {
4968 arg2 = wxString_in_helper(obj1);
4969 if (arg2 == NULL) SWIG_fail;
4970 temp2 = true;
4971 }
4972 }
4973 if (obj2) {
4974 {
4975 arg3 = wxString_in_helper(obj2);
4976 if (arg3 == NULL) SWIG_fail;
4977 temp3 = true;
4978 }
4979 }
4980 if (obj3) {
4981 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4982 if (SWIG_arg_fail(4)) SWIG_fail;
4983 }
4984 if (obj4) {
4985 {
4986 arg5 = (int)(SWIG_As_int(obj4));
4987 if (SWIG_arg_fail(5)) SWIG_fail;
4988 }
4989 }
4990 if (obj5) {
4991 {
4992 arg6 = (int)(SWIG_As_int(obj5));
4993 if (SWIG_arg_fail(6)) SWIG_fail;
4994 }
4995 }
4996 if (obj6) {
4997 {
4998 arg7 = (bool)(SWIG_As_bool(obj6));
4999 if (SWIG_arg_fail(7)) SWIG_fail;
5000 }
5001 }
5002 {
5003 if (!wxPyCheckForApp()) SWIG_fail;
5004 PyThreadState* __tstate = wxPyBeginAllowThreads();
5005 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5006
5007 wxPyEndAllowThreads(__tstate);
5008 if (PyErr_Occurred()) SWIG_fail;
5009 }
5010 {
5011 #if wxUSE_UNICODE
5012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5013 #else
5014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5015 #endif
5016 }
5017 {
5018 if (temp1)
5019 delete arg1;
5020 }
5021 {
5022 if (temp2)
5023 delete arg2;
5024 }
5025 {
5026 if (temp3)
5027 delete arg3;
5028 }
5029 return resultobj;
5030 fail:
5031 {
5032 if (temp1)
5033 delete arg1;
5034 }
5035 {
5036 if (temp2)
5037 delete arg2;
5038 }
5039 {
5040 if (temp3)
5041 delete arg3;
5042 }
5043 return NULL;
5044 }
5045
5046
5047 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5048 PyObject *resultobj;
5049 wxString *arg1 = 0 ;
5050 wxString const &arg2_defvalue = wxPyEmptyString ;
5051 wxString *arg2 = (wxString *) &arg2_defvalue ;
5052 wxString const &arg3_defvalue = wxPyEmptyString ;
5053 wxString *arg3 = (wxString *) &arg3_defvalue ;
5054 wxWindow *arg4 = (wxWindow *) NULL ;
5055 wxString result;
5056 bool temp1 = false ;
5057 bool temp2 = false ;
5058 bool temp3 = false ;
5059 PyObject * obj0 = 0 ;
5060 PyObject * obj1 = 0 ;
5061 PyObject * obj2 = 0 ;
5062 PyObject * obj3 = 0 ;
5063 char *kwnames[] = {
5064 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5065 };
5066
5067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5068 {
5069 arg1 = wxString_in_helper(obj0);
5070 if (arg1 == NULL) SWIG_fail;
5071 temp1 = true;
5072 }
5073 if (obj1) {
5074 {
5075 arg2 = wxString_in_helper(obj1);
5076 if (arg2 == NULL) SWIG_fail;
5077 temp2 = true;
5078 }
5079 }
5080 if (obj2) {
5081 {
5082 arg3 = wxString_in_helper(obj2);
5083 if (arg3 == NULL) SWIG_fail;
5084 temp3 = true;
5085 }
5086 }
5087 if (obj3) {
5088 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5089 if (SWIG_arg_fail(4)) SWIG_fail;
5090 }
5091 {
5092 if (!wxPyCheckForApp()) SWIG_fail;
5093 PyThreadState* __tstate = wxPyBeginAllowThreads();
5094 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5095
5096 wxPyEndAllowThreads(__tstate);
5097 if (PyErr_Occurred()) SWIG_fail;
5098 }
5099 {
5100 #if wxUSE_UNICODE
5101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5102 #else
5103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5104 #endif
5105 }
5106 {
5107 if (temp1)
5108 delete arg1;
5109 }
5110 {
5111 if (temp2)
5112 delete arg2;
5113 }
5114 {
5115 if (temp3)
5116 delete arg3;
5117 }
5118 return resultobj;
5119 fail:
5120 {
5121 if (temp1)
5122 delete arg1;
5123 }
5124 {
5125 if (temp2)
5126 delete arg2;
5127 }
5128 {
5129 if (temp3)
5130 delete arg3;
5131 }
5132 return NULL;
5133 }
5134
5135
5136 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5137 PyObject *resultobj;
5138 wxString *arg1 = 0 ;
5139 wxString *arg2 = 0 ;
5140 int arg3 ;
5141 wxString *arg4 = (wxString *) 0 ;
5142 wxWindow *arg5 = (wxWindow *) NULL ;
5143 int arg6 = (int) -1 ;
5144 int arg7 = (int) -1 ;
5145 bool arg8 = (bool) true ;
5146 int arg9 = (int) 150 ;
5147 int arg10 = (int) 200 ;
5148 wxString result;
5149 bool temp1 = false ;
5150 bool temp2 = false ;
5151 PyObject * obj0 = 0 ;
5152 PyObject * obj1 = 0 ;
5153 PyObject * obj2 = 0 ;
5154 PyObject * obj3 = 0 ;
5155 PyObject * obj4 = 0 ;
5156 PyObject * obj5 = 0 ;
5157 PyObject * obj6 = 0 ;
5158 PyObject * obj7 = 0 ;
5159 PyObject * obj8 = 0 ;
5160 char *kwnames[] = {
5161 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5162 };
5163
5164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5165 {
5166 arg1 = wxString_in_helper(obj0);
5167 if (arg1 == NULL) SWIG_fail;
5168 temp1 = true;
5169 }
5170 {
5171 arg2 = wxString_in_helper(obj1);
5172 if (arg2 == NULL) SWIG_fail;
5173 temp2 = true;
5174 }
5175 {
5176 arg3 = PyList_Size(obj2);
5177 arg4 = wxString_LIST_helper(obj2);
5178 if (arg4 == NULL) SWIG_fail;
5179 }
5180 if (obj3) {
5181 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5182 if (SWIG_arg_fail(5)) SWIG_fail;
5183 }
5184 if (obj4) {
5185 {
5186 arg6 = (int)(SWIG_As_int(obj4));
5187 if (SWIG_arg_fail(6)) SWIG_fail;
5188 }
5189 }
5190 if (obj5) {
5191 {
5192 arg7 = (int)(SWIG_As_int(obj5));
5193 if (SWIG_arg_fail(7)) SWIG_fail;
5194 }
5195 }
5196 if (obj6) {
5197 {
5198 arg8 = (bool)(SWIG_As_bool(obj6));
5199 if (SWIG_arg_fail(8)) SWIG_fail;
5200 }
5201 }
5202 if (obj7) {
5203 {
5204 arg9 = (int)(SWIG_As_int(obj7));
5205 if (SWIG_arg_fail(9)) SWIG_fail;
5206 }
5207 }
5208 if (obj8) {
5209 {
5210 arg10 = (int)(SWIG_As_int(obj8));
5211 if (SWIG_arg_fail(10)) SWIG_fail;
5212 }
5213 }
5214 {
5215 if (!wxPyCheckForApp()) SWIG_fail;
5216 PyThreadState* __tstate = wxPyBeginAllowThreads();
5217 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5218
5219 wxPyEndAllowThreads(__tstate);
5220 if (PyErr_Occurred()) SWIG_fail;
5221 }
5222 {
5223 #if wxUSE_UNICODE
5224 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5225 #else
5226 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5227 #endif
5228 }
5229 {
5230 if (temp1)
5231 delete arg1;
5232 }
5233 {
5234 if (temp2)
5235 delete arg2;
5236 }
5237 {
5238 if (arg4) delete [] arg4;
5239 }
5240 return resultobj;
5241 fail:
5242 {
5243 if (temp1)
5244 delete arg1;
5245 }
5246 {
5247 if (temp2)
5248 delete arg2;
5249 }
5250 {
5251 if (arg4) delete [] arg4;
5252 }
5253 return NULL;
5254 }
5255
5256
5257 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5258 PyObject *resultobj;
5259 wxString *arg1 = 0 ;
5260 wxString *arg2 = 0 ;
5261 int arg3 ;
5262 wxString *arg4 = (wxString *) 0 ;
5263 wxWindow *arg5 = (wxWindow *) NULL ;
5264 int arg6 = (int) -1 ;
5265 int arg7 = (int) -1 ;
5266 bool arg8 = (bool) true ;
5267 int arg9 = (int) 150 ;
5268 int arg10 = (int) 200 ;
5269 int result;
5270 bool temp1 = false ;
5271 bool temp2 = false ;
5272 PyObject * obj0 = 0 ;
5273 PyObject * obj1 = 0 ;
5274 PyObject * obj2 = 0 ;
5275 PyObject * obj3 = 0 ;
5276 PyObject * obj4 = 0 ;
5277 PyObject * obj5 = 0 ;
5278 PyObject * obj6 = 0 ;
5279 PyObject * obj7 = 0 ;
5280 PyObject * obj8 = 0 ;
5281 char *kwnames[] = {
5282 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5283 };
5284
5285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5286 {
5287 arg1 = wxString_in_helper(obj0);
5288 if (arg1 == NULL) SWIG_fail;
5289 temp1 = true;
5290 }
5291 {
5292 arg2 = wxString_in_helper(obj1);
5293 if (arg2 == NULL) SWIG_fail;
5294 temp2 = true;
5295 }
5296 {
5297 arg3 = PyList_Size(obj2);
5298 arg4 = wxString_LIST_helper(obj2);
5299 if (arg4 == NULL) SWIG_fail;
5300 }
5301 if (obj3) {
5302 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5303 if (SWIG_arg_fail(5)) SWIG_fail;
5304 }
5305 if (obj4) {
5306 {
5307 arg6 = (int)(SWIG_As_int(obj4));
5308 if (SWIG_arg_fail(6)) SWIG_fail;
5309 }
5310 }
5311 if (obj5) {
5312 {
5313 arg7 = (int)(SWIG_As_int(obj5));
5314 if (SWIG_arg_fail(7)) SWIG_fail;
5315 }
5316 }
5317 if (obj6) {
5318 {
5319 arg8 = (bool)(SWIG_As_bool(obj6));
5320 if (SWIG_arg_fail(8)) SWIG_fail;
5321 }
5322 }
5323 if (obj7) {
5324 {
5325 arg9 = (int)(SWIG_As_int(obj7));
5326 if (SWIG_arg_fail(9)) SWIG_fail;
5327 }
5328 }
5329 if (obj8) {
5330 {
5331 arg10 = (int)(SWIG_As_int(obj8));
5332 if (SWIG_arg_fail(10)) SWIG_fail;
5333 }
5334 }
5335 {
5336 if (!wxPyCheckForApp()) SWIG_fail;
5337 PyThreadState* __tstate = wxPyBeginAllowThreads();
5338 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5339
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 {
5344 resultobj = SWIG_From_int((int)(result));
5345 }
5346 {
5347 if (temp1)
5348 delete arg1;
5349 }
5350 {
5351 if (temp2)
5352 delete arg2;
5353 }
5354 {
5355 if (arg4) delete [] arg4;
5356 }
5357 return resultobj;
5358 fail:
5359 {
5360 if (temp1)
5361 delete arg1;
5362 }
5363 {
5364 if (temp2)
5365 delete arg2;
5366 }
5367 {
5368 if (arg4) delete [] arg4;
5369 }
5370 return NULL;
5371 }
5372
5373
5374 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5375 PyObject *resultobj;
5376 wxString *arg1 = 0 ;
5377 wxString const &arg2_defvalue = wxPyEmptyString ;
5378 wxString *arg2 = (wxString *) &arg2_defvalue ;
5379 int arg3 = (int) wxOK|wxCENTRE ;
5380 wxWindow *arg4 = (wxWindow *) NULL ;
5381 int arg5 = (int) -1 ;
5382 int arg6 = (int) -1 ;
5383 int result;
5384 bool temp1 = false ;
5385 bool temp2 = false ;
5386 PyObject * obj0 = 0 ;
5387 PyObject * obj1 = 0 ;
5388 PyObject * obj2 = 0 ;
5389 PyObject * obj3 = 0 ;
5390 PyObject * obj4 = 0 ;
5391 PyObject * obj5 = 0 ;
5392 char *kwnames[] = {
5393 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5394 };
5395
5396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5397 {
5398 arg1 = wxString_in_helper(obj0);
5399 if (arg1 == NULL) SWIG_fail;
5400 temp1 = true;
5401 }
5402 if (obj1) {
5403 {
5404 arg2 = wxString_in_helper(obj1);
5405 if (arg2 == NULL) SWIG_fail;
5406 temp2 = true;
5407 }
5408 }
5409 if (obj2) {
5410 {
5411 arg3 = (int)(SWIG_As_int(obj2));
5412 if (SWIG_arg_fail(3)) SWIG_fail;
5413 }
5414 }
5415 if (obj3) {
5416 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5417 if (SWIG_arg_fail(4)) SWIG_fail;
5418 }
5419 if (obj4) {
5420 {
5421 arg5 = (int)(SWIG_As_int(obj4));
5422 if (SWIG_arg_fail(5)) SWIG_fail;
5423 }
5424 }
5425 if (obj5) {
5426 {
5427 arg6 = (int)(SWIG_As_int(obj5));
5428 if (SWIG_arg_fail(6)) SWIG_fail;
5429 }
5430 }
5431 {
5432 if (!wxPyCheckForApp()) SWIG_fail;
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5435
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 {
5440 resultobj = SWIG_From_int((int)(result));
5441 }
5442 {
5443 if (temp1)
5444 delete arg1;
5445 }
5446 {
5447 if (temp2)
5448 delete arg2;
5449 }
5450 return resultobj;
5451 fail:
5452 {
5453 if (temp1)
5454 delete arg1;
5455 }
5456 {
5457 if (temp2)
5458 delete arg2;
5459 }
5460 return NULL;
5461 }
5462
5463
5464 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5465 PyObject *resultobj;
5466 wxString *arg1 = 0 ;
5467 wxString *arg2 = 0 ;
5468 wxString *arg3 = 0 ;
5469 long arg4 ;
5470 long arg5 = (long) 0 ;
5471 long arg6 = (long) 100 ;
5472 wxWindow *arg7 = (wxWindow *) NULL ;
5473 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5474 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5475 long result;
5476 bool temp1 = false ;
5477 bool temp2 = false ;
5478 bool temp3 = false ;
5479 wxPoint temp8 ;
5480 PyObject * obj0 = 0 ;
5481 PyObject * obj1 = 0 ;
5482 PyObject * obj2 = 0 ;
5483 PyObject * obj3 = 0 ;
5484 PyObject * obj4 = 0 ;
5485 PyObject * obj5 = 0 ;
5486 PyObject * obj6 = 0 ;
5487 PyObject * obj7 = 0 ;
5488 char *kwnames[] = {
5489 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5490 };
5491
5492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5493 {
5494 arg1 = wxString_in_helper(obj0);
5495 if (arg1 == NULL) SWIG_fail;
5496 temp1 = true;
5497 }
5498 {
5499 arg2 = wxString_in_helper(obj1);
5500 if (arg2 == NULL) SWIG_fail;
5501 temp2 = true;
5502 }
5503 {
5504 arg3 = wxString_in_helper(obj2);
5505 if (arg3 == NULL) SWIG_fail;
5506 temp3 = true;
5507 }
5508 {
5509 arg4 = (long)(SWIG_As_long(obj3));
5510 if (SWIG_arg_fail(4)) SWIG_fail;
5511 }
5512 if (obj4) {
5513 {
5514 arg5 = (long)(SWIG_As_long(obj4));
5515 if (SWIG_arg_fail(5)) SWIG_fail;
5516 }
5517 }
5518 if (obj5) {
5519 {
5520 arg6 = (long)(SWIG_As_long(obj5));
5521 if (SWIG_arg_fail(6)) SWIG_fail;
5522 }
5523 }
5524 if (obj6) {
5525 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5526 if (SWIG_arg_fail(7)) SWIG_fail;
5527 }
5528 if (obj7) {
5529 {
5530 arg8 = &temp8;
5531 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5532 }
5533 }
5534 {
5535 if (!wxPyCheckForApp()) SWIG_fail;
5536 PyThreadState* __tstate = wxPyBeginAllowThreads();
5537 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5538
5539 wxPyEndAllowThreads(__tstate);
5540 if (PyErr_Occurred()) SWIG_fail;
5541 }
5542 {
5543 resultobj = SWIG_From_long((long)(result));
5544 }
5545 {
5546 if (temp1)
5547 delete arg1;
5548 }
5549 {
5550 if (temp2)
5551 delete arg2;
5552 }
5553 {
5554 if (temp3)
5555 delete arg3;
5556 }
5557 return resultobj;
5558 fail:
5559 {
5560 if (temp1)
5561 delete arg1;
5562 }
5563 {
5564 if (temp2)
5565 delete arg2;
5566 }
5567 {
5568 if (temp3)
5569 delete arg3;
5570 }
5571 return NULL;
5572 }
5573
5574
5575 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5576 PyObject *resultobj;
5577 bool result;
5578 char *kwnames[] = {
5579 NULL
5580 };
5581
5582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5583 {
5584 if (!wxPyCheckForApp()) SWIG_fail;
5585 PyThreadState* __tstate = wxPyBeginAllowThreads();
5586 result = (bool)wxColourDisplay();
5587
5588 wxPyEndAllowThreads(__tstate);
5589 if (PyErr_Occurred()) SWIG_fail;
5590 }
5591 {
5592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5593 }
5594 return resultobj;
5595 fail:
5596 return NULL;
5597 }
5598
5599
5600 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5601 PyObject *resultobj;
5602 int result;
5603 char *kwnames[] = {
5604 NULL
5605 };
5606
5607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5608 {
5609 if (!wxPyCheckForApp()) SWIG_fail;
5610 PyThreadState* __tstate = wxPyBeginAllowThreads();
5611 result = (int)wxDisplayDepth();
5612
5613 wxPyEndAllowThreads(__tstate);
5614 if (PyErr_Occurred()) SWIG_fail;
5615 }
5616 {
5617 resultobj = SWIG_From_int((int)(result));
5618 }
5619 return resultobj;
5620 fail:
5621 return NULL;
5622 }
5623
5624
5625 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5626 PyObject *resultobj;
5627 int result;
5628 char *kwnames[] = {
5629 NULL
5630 };
5631
5632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5633 {
5634 if (!wxPyCheckForApp()) SWIG_fail;
5635 PyThreadState* __tstate = wxPyBeginAllowThreads();
5636 result = (int)wxGetDisplayDepth();
5637
5638 wxPyEndAllowThreads(__tstate);
5639 if (PyErr_Occurred()) SWIG_fail;
5640 }
5641 {
5642 resultobj = SWIG_From_int((int)(result));
5643 }
5644 return resultobj;
5645 fail:
5646 return NULL;
5647 }
5648
5649
5650 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5651 PyObject *resultobj;
5652 int *arg1 = (int *) 0 ;
5653 int *arg2 = (int *) 0 ;
5654 int temp1 ;
5655 int res1 = 0 ;
5656 int temp2 ;
5657 int res2 = 0 ;
5658 char *kwnames[] = {
5659 NULL
5660 };
5661
5662 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5663 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5665 {
5666 if (!wxPyCheckForApp()) SWIG_fail;
5667 PyThreadState* __tstate = wxPyBeginAllowThreads();
5668 wxDisplaySize(arg1,arg2);
5669
5670 wxPyEndAllowThreads(__tstate);
5671 if (PyErr_Occurred()) SWIG_fail;
5672 }
5673 Py_INCREF(Py_None); resultobj = Py_None;
5674 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5675 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5676 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5677 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5678 return resultobj;
5679 fail:
5680 return NULL;
5681 }
5682
5683
5684 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5685 PyObject *resultobj;
5686 wxSize result;
5687 char *kwnames[] = {
5688 NULL
5689 };
5690
5691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5692 {
5693 if (!wxPyCheckForApp()) SWIG_fail;
5694 PyThreadState* __tstate = wxPyBeginAllowThreads();
5695 result = wxGetDisplaySize();
5696
5697 wxPyEndAllowThreads(__tstate);
5698 if (PyErr_Occurred()) SWIG_fail;
5699 }
5700 {
5701 wxSize * resultptr;
5702 resultptr = new wxSize((wxSize &)(result));
5703 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5704 }
5705 return resultobj;
5706 fail:
5707 return NULL;
5708 }
5709
5710
5711 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5712 PyObject *resultobj;
5713 int *arg1 = (int *) 0 ;
5714 int *arg2 = (int *) 0 ;
5715 int temp1 ;
5716 int res1 = 0 ;
5717 int temp2 ;
5718 int res2 = 0 ;
5719 char *kwnames[] = {
5720 NULL
5721 };
5722
5723 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5724 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5726 {
5727 if (!wxPyCheckForApp()) SWIG_fail;
5728 PyThreadState* __tstate = wxPyBeginAllowThreads();
5729 wxDisplaySizeMM(arg1,arg2);
5730
5731 wxPyEndAllowThreads(__tstate);
5732 if (PyErr_Occurred()) SWIG_fail;
5733 }
5734 Py_INCREF(Py_None); resultobj = Py_None;
5735 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5736 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5737 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5738 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5739 return resultobj;
5740 fail:
5741 return NULL;
5742 }
5743
5744
5745 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5746 PyObject *resultobj;
5747 wxSize result;
5748 char *kwnames[] = {
5749 NULL
5750 };
5751
5752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5753 {
5754 if (!wxPyCheckForApp()) SWIG_fail;
5755 PyThreadState* __tstate = wxPyBeginAllowThreads();
5756 result = wxGetDisplaySizeMM();
5757
5758 wxPyEndAllowThreads(__tstate);
5759 if (PyErr_Occurred()) SWIG_fail;
5760 }
5761 {
5762 wxSize * resultptr;
5763 resultptr = new wxSize((wxSize &)(result));
5764 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5765 }
5766 return resultobj;
5767 fail:
5768 return NULL;
5769 }
5770
5771
5772 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5773 PyObject *resultobj;
5774 int *arg1 = (int *) 0 ;
5775 int *arg2 = (int *) 0 ;
5776 int *arg3 = (int *) 0 ;
5777 int *arg4 = (int *) 0 ;
5778 int temp1 ;
5779 int res1 = 0 ;
5780 int temp2 ;
5781 int res2 = 0 ;
5782 int temp3 ;
5783 int res3 = 0 ;
5784 int temp4 ;
5785 int res4 = 0 ;
5786 char *kwnames[] = {
5787 NULL
5788 };
5789
5790 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5791 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5792 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5793 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5795 {
5796 if (!wxPyCheckForApp()) SWIG_fail;
5797 PyThreadState* __tstate = wxPyBeginAllowThreads();
5798 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5799
5800 wxPyEndAllowThreads(__tstate);
5801 if (PyErr_Occurred()) SWIG_fail;
5802 }
5803 Py_INCREF(Py_None); resultobj = Py_None;
5804 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5805 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5806 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5807 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5808 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5809 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5810 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5811 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5812 return resultobj;
5813 fail:
5814 return NULL;
5815 }
5816
5817
5818 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5819 PyObject *resultobj;
5820 wxRect result;
5821 char *kwnames[] = {
5822 NULL
5823 };
5824
5825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5826 {
5827 if (!wxPyCheckForApp()) SWIG_fail;
5828 PyThreadState* __tstate = wxPyBeginAllowThreads();
5829 result = wxGetClientDisplayRect();
5830
5831 wxPyEndAllowThreads(__tstate);
5832 if (PyErr_Occurred()) SWIG_fail;
5833 }
5834 {
5835 wxRect * resultptr;
5836 resultptr = new wxRect((wxRect &)(result));
5837 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5838 }
5839 return resultobj;
5840 fail:
5841 return NULL;
5842 }
5843
5844
5845 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5846 PyObject *resultobj;
5847 wxCursor *arg1 = 0 ;
5848 PyObject * obj0 = 0 ;
5849 char *kwnames[] = {
5850 (char *) "cursor", NULL
5851 };
5852
5853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5854 {
5855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5856 if (SWIG_arg_fail(1)) SWIG_fail;
5857 if (arg1 == NULL) {
5858 SWIG_null_ref("wxCursor");
5859 }
5860 if (SWIG_arg_fail(1)) SWIG_fail;
5861 }
5862 {
5863 if (!wxPyCheckForApp()) SWIG_fail;
5864 PyThreadState* __tstate = wxPyBeginAllowThreads();
5865 wxSetCursor(*arg1);
5866
5867 wxPyEndAllowThreads(__tstate);
5868 if (PyErr_Occurred()) SWIG_fail;
5869 }
5870 Py_INCREF(Py_None); resultobj = Py_None;
5871 return resultobj;
5872 fail:
5873 return NULL;
5874 }
5875
5876
5877 static PyObject *_wrap_GetXDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5878 PyObject *resultobj;
5879 void *result;
5880 char *kwnames[] = {
5881 NULL
5882 };
5883
5884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetXDisplay",kwnames)) goto fail;
5885 {
5886 if (!wxPyCheckForApp()) SWIG_fail;
5887 PyThreadState* __tstate = wxPyBeginAllowThreads();
5888 result = (void *)wxGetXDisplay();
5889
5890 wxPyEndAllowThreads(__tstate);
5891 if (PyErr_Occurred()) SWIG_fail;
5892 }
5893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
5894 return resultobj;
5895 fail:
5896 return NULL;
5897 }
5898
5899
5900 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5901 PyObject *resultobj;
5902 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5903 PyObject * obj0 = 0 ;
5904 char *kwnames[] = {
5905 (char *) "cursor", NULL
5906 };
5907
5908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5909 if (obj0) {
5910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5911 if (SWIG_arg_fail(1)) SWIG_fail;
5912 }
5913 {
5914 if (!wxPyCheckForApp()) SWIG_fail;
5915 PyThreadState* __tstate = wxPyBeginAllowThreads();
5916 wxBeginBusyCursor(arg1);
5917
5918 wxPyEndAllowThreads(__tstate);
5919 if (PyErr_Occurred()) SWIG_fail;
5920 }
5921 Py_INCREF(Py_None); resultobj = Py_None;
5922 return resultobj;
5923 fail:
5924 return NULL;
5925 }
5926
5927
5928 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5929 PyObject *resultobj;
5930 wxWindow *result;
5931 char *kwnames[] = {
5932 NULL
5933 };
5934
5935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5936 {
5937 if (!wxPyCheckForApp()) SWIG_fail;
5938 PyThreadState* __tstate = wxPyBeginAllowThreads();
5939 result = (wxWindow *)wxGetActiveWindow();
5940
5941 wxPyEndAllowThreads(__tstate);
5942 if (PyErr_Occurred()) SWIG_fail;
5943 }
5944 {
5945 resultobj = wxPyMake_wxObject(result, 0);
5946 }
5947 return resultobj;
5948 fail:
5949 return NULL;
5950 }
5951
5952
5953 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5954 PyObject *resultobj;
5955 wxPoint *arg1 = 0 ;
5956 wxWindow *result;
5957 wxPoint temp1 ;
5958 PyObject * obj0 = 0 ;
5959 char *kwnames[] = {
5960 (char *) "pt", NULL
5961 };
5962
5963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5964 {
5965 arg1 = &temp1;
5966 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5967 }
5968 {
5969 if (!wxPyCheckForApp()) SWIG_fail;
5970 PyThreadState* __tstate = wxPyBeginAllowThreads();
5971 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5972
5973 wxPyEndAllowThreads(__tstate);
5974 if (PyErr_Occurred()) SWIG_fail;
5975 }
5976 {
5977 resultobj = wxPyMake_wxObject(result, 0);
5978 }
5979 return resultobj;
5980 fail:
5981 return NULL;
5982 }
5983
5984
5985 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5986 PyObject *resultobj;
5987 wxPoint *arg1 = 0 ;
5988 wxWindow *result;
5989 wxPoint temp1 ;
5990 PyObject * obj0 = 0 ;
5991 char *kwnames[] = {
5992 (char *) "pt", NULL
5993 };
5994
5995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5996 {
5997 arg1 = &temp1;
5998 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5999 }
6000 {
6001 if (!wxPyCheckForApp()) SWIG_fail;
6002 PyThreadState* __tstate = wxPyBeginAllowThreads();
6003 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6004
6005 wxPyEndAllowThreads(__tstate);
6006 if (PyErr_Occurred()) SWIG_fail;
6007 }
6008 {
6009 resultobj = wxPyMake_wxObject(result, 0);
6010 }
6011 return resultobj;
6012 fail:
6013 return NULL;
6014 }
6015
6016
6017 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
6018 PyObject *resultobj;
6019 wxWindow *arg1 = (wxWindow *) 0 ;
6020 wxWindow *result;
6021 PyObject * obj0 = 0 ;
6022 char *kwnames[] = {
6023 (char *) "win", NULL
6024 };
6025
6026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
6027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6028 if (SWIG_arg_fail(1)) SWIG_fail;
6029 {
6030 if (!wxPyCheckForApp()) SWIG_fail;
6031 PyThreadState* __tstate = wxPyBeginAllowThreads();
6032 result = (wxWindow *)wxGetTopLevelParent(arg1);
6033
6034 wxPyEndAllowThreads(__tstate);
6035 if (PyErr_Occurred()) SWIG_fail;
6036 }
6037 {
6038 resultobj = wxPyMake_wxObject(result, 0);
6039 }
6040 return resultobj;
6041 fail:
6042 return NULL;
6043 }
6044
6045
6046 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6047 PyObject *resultobj;
6048 wxString *arg1 = 0 ;
6049 bool result;
6050 bool temp1 = false ;
6051 PyObject * obj0 = 0 ;
6052 char *kwnames[] = {
6053 (char *) "url", NULL
6054 };
6055
6056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6057 {
6058 arg1 = wxString_in_helper(obj0);
6059 if (arg1 == NULL) SWIG_fail;
6060 temp1 = true;
6061 }
6062 {
6063 PyThreadState* __tstate = wxPyBeginAllowThreads();
6064 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6065
6066 wxPyEndAllowThreads(__tstate);
6067 if (PyErr_Occurred()) SWIG_fail;
6068 }
6069 {
6070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6071 }
6072 {
6073 if (temp1)
6074 delete arg1;
6075 }
6076 return resultobj;
6077 fail:
6078 {
6079 if (temp1)
6080 delete arg1;
6081 }
6082 return NULL;
6083 }
6084
6085
6086 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6087 PyObject *resultobj;
6088 wxKeyCode arg1 ;
6089 bool result;
6090 PyObject * obj0 = 0 ;
6091 char *kwnames[] = {
6092 (char *) "key", NULL
6093 };
6094
6095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6096 {
6097 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6098 if (SWIG_arg_fail(1)) SWIG_fail;
6099 }
6100 {
6101 if (!wxPyCheckForApp()) SWIG_fail;
6102 PyThreadState* __tstate = wxPyBeginAllowThreads();
6103 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6104
6105 wxPyEndAllowThreads(__tstate);
6106 if (PyErr_Occurred()) SWIG_fail;
6107 }
6108 {
6109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6110 }
6111 return resultobj;
6112 fail:
6113 return NULL;
6114 }
6115
6116
6117 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6118 PyObject *resultobj;
6119 char *kwnames[] = {
6120 NULL
6121 };
6122
6123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6124 {
6125 if (!wxPyCheckForApp()) SWIG_fail;
6126 PyThreadState* __tstate = wxPyBeginAllowThreads();
6127 wxWakeUpMainThread();
6128
6129 wxPyEndAllowThreads(__tstate);
6130 if (PyErr_Occurred()) SWIG_fail;
6131 }
6132 Py_INCREF(Py_None); resultobj = Py_None;
6133 return resultobj;
6134 fail:
6135 return NULL;
6136 }
6137
6138
6139 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6140 PyObject *resultobj;
6141 char *kwnames[] = {
6142 NULL
6143 };
6144
6145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6146 {
6147 if (!wxPyCheckForApp()) SWIG_fail;
6148 PyThreadState* __tstate = wxPyBeginAllowThreads();
6149 wxMutexGuiEnter();
6150
6151 wxPyEndAllowThreads(__tstate);
6152 if (PyErr_Occurred()) SWIG_fail;
6153 }
6154 Py_INCREF(Py_None); resultobj = Py_None;
6155 return resultobj;
6156 fail:
6157 return NULL;
6158 }
6159
6160
6161 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6162 PyObject *resultobj;
6163 char *kwnames[] = {
6164 NULL
6165 };
6166
6167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6168 {
6169 if (!wxPyCheckForApp()) SWIG_fail;
6170 PyThreadState* __tstate = wxPyBeginAllowThreads();
6171 wxMutexGuiLeave();
6172
6173 wxPyEndAllowThreads(__tstate);
6174 if (PyErr_Occurred()) SWIG_fail;
6175 }
6176 Py_INCREF(Py_None); resultobj = Py_None;
6177 return resultobj;
6178 fail:
6179 return NULL;
6180 }
6181
6182
6183 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6184 PyObject *resultobj;
6185 wxMutexGuiLocker *result;
6186 char *kwnames[] = {
6187 NULL
6188 };
6189
6190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6191 {
6192 if (!wxPyCheckForApp()) SWIG_fail;
6193 PyThreadState* __tstate = wxPyBeginAllowThreads();
6194 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6195
6196 wxPyEndAllowThreads(__tstate);
6197 if (PyErr_Occurred()) SWIG_fail;
6198 }
6199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj;
6208 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6209 PyObject * obj0 = 0 ;
6210 char *kwnames[] = {
6211 (char *) "self", NULL
6212 };
6213
6214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6216 if (SWIG_arg_fail(1)) SWIG_fail;
6217 {
6218 PyThreadState* __tstate = wxPyBeginAllowThreads();
6219 delete arg1;
6220
6221 wxPyEndAllowThreads(__tstate);
6222 if (PyErr_Occurred()) SWIG_fail;
6223 }
6224 Py_INCREF(Py_None); resultobj = Py_None;
6225 return resultobj;
6226 fail:
6227 return NULL;
6228 }
6229
6230
6231 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6232 PyObject *obj;
6233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6234 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6235 Py_INCREF(obj);
6236 return Py_BuildValue((char *)"");
6237 }
6238 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6239 PyObject *resultobj;
6240 bool result;
6241 char *kwnames[] = {
6242 NULL
6243 };
6244
6245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6246 {
6247 PyThreadState* __tstate = wxPyBeginAllowThreads();
6248 result = (bool)wxThread_IsMain();
6249
6250 wxPyEndAllowThreads(__tstate);
6251 if (PyErr_Occurred()) SWIG_fail;
6252 }
6253 {
6254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6255 }
6256 return resultobj;
6257 fail:
6258 return NULL;
6259 }
6260
6261
6262 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6263 PyObject *resultobj;
6264 wxString *arg1 = 0 ;
6265 wxToolTip *result;
6266 bool temp1 = false ;
6267 PyObject * obj0 = 0 ;
6268 char *kwnames[] = {
6269 (char *) "tip", NULL
6270 };
6271
6272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6273 {
6274 arg1 = wxString_in_helper(obj0);
6275 if (arg1 == NULL) SWIG_fail;
6276 temp1 = true;
6277 }
6278 {
6279 if (!wxPyCheckForApp()) SWIG_fail;
6280 PyThreadState* __tstate = wxPyBeginAllowThreads();
6281 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6282
6283 wxPyEndAllowThreads(__tstate);
6284 if (PyErr_Occurred()) SWIG_fail;
6285 }
6286 {
6287 resultobj = wxPyMake_wxObject(result, 1);
6288 }
6289 {
6290 if (temp1)
6291 delete arg1;
6292 }
6293 return resultobj;
6294 fail:
6295 {
6296 if (temp1)
6297 delete arg1;
6298 }
6299 return NULL;
6300 }
6301
6302
6303 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6304 PyObject *resultobj;
6305 wxToolTip *arg1 = (wxToolTip *) 0 ;
6306 wxString *arg2 = 0 ;
6307 bool temp2 = false ;
6308 PyObject * obj0 = 0 ;
6309 PyObject * obj1 = 0 ;
6310 char *kwnames[] = {
6311 (char *) "self",(char *) "tip", NULL
6312 };
6313
6314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6316 if (SWIG_arg_fail(1)) SWIG_fail;
6317 {
6318 arg2 = wxString_in_helper(obj1);
6319 if (arg2 == NULL) SWIG_fail;
6320 temp2 = true;
6321 }
6322 {
6323 PyThreadState* __tstate = wxPyBeginAllowThreads();
6324 (arg1)->SetTip((wxString const &)*arg2);
6325
6326 wxPyEndAllowThreads(__tstate);
6327 if (PyErr_Occurred()) SWIG_fail;
6328 }
6329 Py_INCREF(Py_None); resultobj = Py_None;
6330 {
6331 if (temp2)
6332 delete arg2;
6333 }
6334 return resultobj;
6335 fail:
6336 {
6337 if (temp2)
6338 delete arg2;
6339 }
6340 return NULL;
6341 }
6342
6343
6344 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6345 PyObject *resultobj;
6346 wxToolTip *arg1 = (wxToolTip *) 0 ;
6347 wxString result;
6348 PyObject * obj0 = 0 ;
6349 char *kwnames[] = {
6350 (char *) "self", NULL
6351 };
6352
6353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6355 if (SWIG_arg_fail(1)) SWIG_fail;
6356 {
6357 PyThreadState* __tstate = wxPyBeginAllowThreads();
6358 result = (arg1)->GetTip();
6359
6360 wxPyEndAllowThreads(__tstate);
6361 if (PyErr_Occurred()) SWIG_fail;
6362 }
6363 {
6364 #if wxUSE_UNICODE
6365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6366 #else
6367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6368 #endif
6369 }
6370 return resultobj;
6371 fail:
6372 return NULL;
6373 }
6374
6375
6376 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6377 PyObject *resultobj;
6378 wxToolTip *arg1 = (wxToolTip *) 0 ;
6379 wxWindow *result;
6380 PyObject * obj0 = 0 ;
6381 char *kwnames[] = {
6382 (char *) "self", NULL
6383 };
6384
6385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6387 if (SWIG_arg_fail(1)) SWIG_fail;
6388 {
6389 PyThreadState* __tstate = wxPyBeginAllowThreads();
6390 result = (wxWindow *)(arg1)->GetWindow();
6391
6392 wxPyEndAllowThreads(__tstate);
6393 if (PyErr_Occurred()) SWIG_fail;
6394 }
6395 {
6396 resultobj = wxPyMake_wxObject(result, 0);
6397 }
6398 return resultobj;
6399 fail:
6400 return NULL;
6401 }
6402
6403
6404 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6405 PyObject *resultobj;
6406 bool arg1 ;
6407 PyObject * obj0 = 0 ;
6408 char *kwnames[] = {
6409 (char *) "flag", NULL
6410 };
6411
6412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6413 {
6414 arg1 = (bool)(SWIG_As_bool(obj0));
6415 if (SWIG_arg_fail(1)) SWIG_fail;
6416 }
6417 {
6418 PyThreadState* __tstate = wxPyBeginAllowThreads();
6419 wxToolTip::Enable(arg1);
6420
6421 wxPyEndAllowThreads(__tstate);
6422 if (PyErr_Occurred()) SWIG_fail;
6423 }
6424 Py_INCREF(Py_None); resultobj = Py_None;
6425 return resultobj;
6426 fail:
6427 return NULL;
6428 }
6429
6430
6431 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6432 PyObject *resultobj;
6433 long arg1 ;
6434 PyObject * obj0 = 0 ;
6435 char *kwnames[] = {
6436 (char *) "milliseconds", NULL
6437 };
6438
6439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6440 {
6441 arg1 = (long)(SWIG_As_long(obj0));
6442 if (SWIG_arg_fail(1)) SWIG_fail;
6443 }
6444 {
6445 PyThreadState* __tstate = wxPyBeginAllowThreads();
6446 wxToolTip::SetDelay(arg1);
6447
6448 wxPyEndAllowThreads(__tstate);
6449 if (PyErr_Occurred()) SWIG_fail;
6450 }
6451 Py_INCREF(Py_None); resultobj = Py_None;
6452 return resultobj;
6453 fail:
6454 return NULL;
6455 }
6456
6457
6458 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6459 PyObject *obj;
6460 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6461 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6462 Py_INCREF(obj);
6463 return Py_BuildValue((char *)"");
6464 }
6465 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6466 PyObject *resultobj;
6467 wxWindow *arg1 = (wxWindow *) 0 ;
6468 wxSize *arg2 = 0 ;
6469 wxCaret *result;
6470 wxSize temp2 ;
6471 PyObject * obj0 = 0 ;
6472 PyObject * obj1 = 0 ;
6473 char *kwnames[] = {
6474 (char *) "window",(char *) "size", NULL
6475 };
6476
6477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6479 if (SWIG_arg_fail(1)) SWIG_fail;
6480 {
6481 arg2 = &temp2;
6482 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6483 }
6484 {
6485 if (!wxPyCheckForApp()) SWIG_fail;
6486 PyThreadState* __tstate = wxPyBeginAllowThreads();
6487 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6488
6489 wxPyEndAllowThreads(__tstate);
6490 if (PyErr_Occurred()) SWIG_fail;
6491 }
6492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6493 return resultobj;
6494 fail:
6495 return NULL;
6496 }
6497
6498
6499 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6500 PyObject *resultobj;
6501 wxCaret *arg1 = (wxCaret *) 0 ;
6502 PyObject * obj0 = 0 ;
6503 char *kwnames[] = {
6504 (char *) "self", NULL
6505 };
6506
6507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6509 if (SWIG_arg_fail(1)) SWIG_fail;
6510 {
6511 PyThreadState* __tstate = wxPyBeginAllowThreads();
6512 wxCaret_Destroy(arg1);
6513
6514 wxPyEndAllowThreads(__tstate);
6515 if (PyErr_Occurred()) SWIG_fail;
6516 }
6517 Py_INCREF(Py_None); resultobj = Py_None;
6518 return resultobj;
6519 fail:
6520 return NULL;
6521 }
6522
6523
6524 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6525 PyObject *resultobj;
6526 wxCaret *arg1 = (wxCaret *) 0 ;
6527 bool result;
6528 PyObject * obj0 = 0 ;
6529 char *kwnames[] = {
6530 (char *) "self", NULL
6531 };
6532
6533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6535 if (SWIG_arg_fail(1)) SWIG_fail;
6536 {
6537 PyThreadState* __tstate = wxPyBeginAllowThreads();
6538 result = (bool)(arg1)->IsOk();
6539
6540 wxPyEndAllowThreads(__tstate);
6541 if (PyErr_Occurred()) SWIG_fail;
6542 }
6543 {
6544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6545 }
6546 return resultobj;
6547 fail:
6548 return NULL;
6549 }
6550
6551
6552 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6553 PyObject *resultobj;
6554 wxCaret *arg1 = (wxCaret *) 0 ;
6555 bool result;
6556 PyObject * obj0 = 0 ;
6557 char *kwnames[] = {
6558 (char *) "self", NULL
6559 };
6560
6561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6563 if (SWIG_arg_fail(1)) SWIG_fail;
6564 {
6565 PyThreadState* __tstate = wxPyBeginAllowThreads();
6566 result = (bool)(arg1)->IsVisible();
6567
6568 wxPyEndAllowThreads(__tstate);
6569 if (PyErr_Occurred()) SWIG_fail;
6570 }
6571 {
6572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6573 }
6574 return resultobj;
6575 fail:
6576 return NULL;
6577 }
6578
6579
6580 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6581 PyObject *resultobj;
6582 wxCaret *arg1 = (wxCaret *) 0 ;
6583 wxPoint result;
6584 PyObject * obj0 = 0 ;
6585 char *kwnames[] = {
6586 (char *) "self", NULL
6587 };
6588
6589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6591 if (SWIG_arg_fail(1)) SWIG_fail;
6592 {
6593 PyThreadState* __tstate = wxPyBeginAllowThreads();
6594 result = (arg1)->GetPosition();
6595
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 {
6600 wxPoint * resultptr;
6601 resultptr = new wxPoint((wxPoint &)(result));
6602 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6603 }
6604 return resultobj;
6605 fail:
6606 return NULL;
6607 }
6608
6609
6610 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6611 PyObject *resultobj;
6612 wxCaret *arg1 = (wxCaret *) 0 ;
6613 int *arg2 = (int *) 0 ;
6614 int *arg3 = (int *) 0 ;
6615 int temp2 ;
6616 int res2 = 0 ;
6617 int temp3 ;
6618 int res3 = 0 ;
6619 PyObject * obj0 = 0 ;
6620 char *kwnames[] = {
6621 (char *) "self", NULL
6622 };
6623
6624 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6625 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6628 if (SWIG_arg_fail(1)) SWIG_fail;
6629 {
6630 PyThreadState* __tstate = wxPyBeginAllowThreads();
6631 (arg1)->GetPosition(arg2,arg3);
6632
6633 wxPyEndAllowThreads(__tstate);
6634 if (PyErr_Occurred()) SWIG_fail;
6635 }
6636 Py_INCREF(Py_None); resultobj = Py_None;
6637 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6638 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6639 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6640 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6641 return resultobj;
6642 fail:
6643 return NULL;
6644 }
6645
6646
6647 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6648 PyObject *resultobj;
6649 wxCaret *arg1 = (wxCaret *) 0 ;
6650 wxSize result;
6651 PyObject * obj0 = 0 ;
6652 char *kwnames[] = {
6653 (char *) "self", NULL
6654 };
6655
6656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6658 if (SWIG_arg_fail(1)) SWIG_fail;
6659 {
6660 PyThreadState* __tstate = wxPyBeginAllowThreads();
6661 result = (arg1)->GetSize();
6662
6663 wxPyEndAllowThreads(__tstate);
6664 if (PyErr_Occurred()) SWIG_fail;
6665 }
6666 {
6667 wxSize * resultptr;
6668 resultptr = new wxSize((wxSize &)(result));
6669 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6670 }
6671 return resultobj;
6672 fail:
6673 return NULL;
6674 }
6675
6676
6677 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6678 PyObject *resultobj;
6679 wxCaret *arg1 = (wxCaret *) 0 ;
6680 int *arg2 = (int *) 0 ;
6681 int *arg3 = (int *) 0 ;
6682 int temp2 ;
6683 int res2 = 0 ;
6684 int temp3 ;
6685 int res3 = 0 ;
6686 PyObject * obj0 = 0 ;
6687 char *kwnames[] = {
6688 (char *) "self", NULL
6689 };
6690
6691 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6692 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6695 if (SWIG_arg_fail(1)) SWIG_fail;
6696 {
6697 PyThreadState* __tstate = wxPyBeginAllowThreads();
6698 (arg1)->GetSize(arg2,arg3);
6699
6700 wxPyEndAllowThreads(__tstate);
6701 if (PyErr_Occurred()) SWIG_fail;
6702 }
6703 Py_INCREF(Py_None); resultobj = Py_None;
6704 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6705 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6706 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6707 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6708 return resultobj;
6709 fail:
6710 return NULL;
6711 }
6712
6713
6714 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6715 PyObject *resultobj;
6716 wxCaret *arg1 = (wxCaret *) 0 ;
6717 wxWindow *result;
6718 PyObject * obj0 = 0 ;
6719 char *kwnames[] = {
6720 (char *) "self", NULL
6721 };
6722
6723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6725 if (SWIG_arg_fail(1)) SWIG_fail;
6726 {
6727 PyThreadState* __tstate = wxPyBeginAllowThreads();
6728 result = (wxWindow *)(arg1)->GetWindow();
6729
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 {
6734 resultobj = wxPyMake_wxObject(result, 0);
6735 }
6736 return resultobj;
6737 fail:
6738 return NULL;
6739 }
6740
6741
6742 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6743 PyObject *resultobj;
6744 wxCaret *arg1 = (wxCaret *) 0 ;
6745 int arg2 ;
6746 int arg3 ;
6747 PyObject * obj0 = 0 ;
6748 PyObject * obj1 = 0 ;
6749 PyObject * obj2 = 0 ;
6750 char *kwnames[] = {
6751 (char *) "self",(char *) "x",(char *) "y", NULL
6752 };
6753
6754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6756 if (SWIG_arg_fail(1)) SWIG_fail;
6757 {
6758 arg2 = (int)(SWIG_As_int(obj1));
6759 if (SWIG_arg_fail(2)) SWIG_fail;
6760 }
6761 {
6762 arg3 = (int)(SWIG_As_int(obj2));
6763 if (SWIG_arg_fail(3)) SWIG_fail;
6764 }
6765 {
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 (arg1)->Move(arg2,arg3);
6768
6769 wxPyEndAllowThreads(__tstate);
6770 if (PyErr_Occurred()) SWIG_fail;
6771 }
6772 Py_INCREF(Py_None); resultobj = Py_None;
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6780 PyObject *resultobj;
6781 wxCaret *arg1 = (wxCaret *) 0 ;
6782 wxPoint *arg2 = 0 ;
6783 wxPoint temp2 ;
6784 PyObject * obj0 = 0 ;
6785 PyObject * obj1 = 0 ;
6786 char *kwnames[] = {
6787 (char *) "self",(char *) "pt", NULL
6788 };
6789
6790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6792 if (SWIG_arg_fail(1)) SWIG_fail;
6793 {
6794 arg2 = &temp2;
6795 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6796 }
6797 {
6798 PyThreadState* __tstate = wxPyBeginAllowThreads();
6799 (arg1)->Move((wxPoint const &)*arg2);
6800
6801 wxPyEndAllowThreads(__tstate);
6802 if (PyErr_Occurred()) SWIG_fail;
6803 }
6804 Py_INCREF(Py_None); resultobj = Py_None;
6805 return resultobj;
6806 fail:
6807 return NULL;
6808 }
6809
6810
6811 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6812 PyObject *resultobj;
6813 wxCaret *arg1 = (wxCaret *) 0 ;
6814 int arg2 ;
6815 int arg3 ;
6816 PyObject * obj0 = 0 ;
6817 PyObject * obj1 = 0 ;
6818 PyObject * obj2 = 0 ;
6819 char *kwnames[] = {
6820 (char *) "self",(char *) "width",(char *) "height", NULL
6821 };
6822
6823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6825 if (SWIG_arg_fail(1)) SWIG_fail;
6826 {
6827 arg2 = (int)(SWIG_As_int(obj1));
6828 if (SWIG_arg_fail(2)) SWIG_fail;
6829 }
6830 {
6831 arg3 = (int)(SWIG_As_int(obj2));
6832 if (SWIG_arg_fail(3)) SWIG_fail;
6833 }
6834 {
6835 PyThreadState* __tstate = wxPyBeginAllowThreads();
6836 (arg1)->SetSize(arg2,arg3);
6837
6838 wxPyEndAllowThreads(__tstate);
6839 if (PyErr_Occurred()) SWIG_fail;
6840 }
6841 Py_INCREF(Py_None); resultobj = Py_None;
6842 return resultobj;
6843 fail:
6844 return NULL;
6845 }
6846
6847
6848 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6849 PyObject *resultobj;
6850 wxCaret *arg1 = (wxCaret *) 0 ;
6851 wxSize *arg2 = 0 ;
6852 wxSize temp2 ;
6853 PyObject * obj0 = 0 ;
6854 PyObject * obj1 = 0 ;
6855 char *kwnames[] = {
6856 (char *) "self",(char *) "size", NULL
6857 };
6858
6859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6861 if (SWIG_arg_fail(1)) SWIG_fail;
6862 {
6863 arg2 = &temp2;
6864 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6865 }
6866 {
6867 PyThreadState* __tstate = wxPyBeginAllowThreads();
6868 (arg1)->SetSize((wxSize const &)*arg2);
6869
6870 wxPyEndAllowThreads(__tstate);
6871 if (PyErr_Occurred()) SWIG_fail;
6872 }
6873 Py_INCREF(Py_None); resultobj = Py_None;
6874 return resultobj;
6875 fail:
6876 return NULL;
6877 }
6878
6879
6880 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6881 PyObject *resultobj;
6882 wxCaret *arg1 = (wxCaret *) 0 ;
6883 int arg2 = (int) true ;
6884 PyObject * obj0 = 0 ;
6885 PyObject * obj1 = 0 ;
6886 char *kwnames[] = {
6887 (char *) "self",(char *) "show", NULL
6888 };
6889
6890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6892 if (SWIG_arg_fail(1)) SWIG_fail;
6893 if (obj1) {
6894 {
6895 arg2 = (int)(SWIG_As_int(obj1));
6896 if (SWIG_arg_fail(2)) SWIG_fail;
6897 }
6898 }
6899 {
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 (arg1)->Show(arg2);
6902
6903 wxPyEndAllowThreads(__tstate);
6904 if (PyErr_Occurred()) SWIG_fail;
6905 }
6906 Py_INCREF(Py_None); resultobj = Py_None;
6907 return resultobj;
6908 fail:
6909 return NULL;
6910 }
6911
6912
6913 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6914 PyObject *resultobj;
6915 wxCaret *arg1 = (wxCaret *) 0 ;
6916 PyObject * obj0 = 0 ;
6917 char *kwnames[] = {
6918 (char *) "self", NULL
6919 };
6920
6921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6923 if (SWIG_arg_fail(1)) SWIG_fail;
6924 {
6925 PyThreadState* __tstate = wxPyBeginAllowThreads();
6926 (arg1)->Hide();
6927
6928 wxPyEndAllowThreads(__tstate);
6929 if (PyErr_Occurred()) SWIG_fail;
6930 }
6931 Py_INCREF(Py_None); resultobj = Py_None;
6932 return resultobj;
6933 fail:
6934 return NULL;
6935 }
6936
6937
6938 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6939 PyObject *resultobj;
6940 int result;
6941 char *kwnames[] = {
6942 NULL
6943 };
6944
6945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6946 {
6947 PyThreadState* __tstate = wxPyBeginAllowThreads();
6948 result = (int)wxCaret::GetBlinkTime();
6949
6950 wxPyEndAllowThreads(__tstate);
6951 if (PyErr_Occurred()) SWIG_fail;
6952 }
6953 {
6954 resultobj = SWIG_From_int((int)(result));
6955 }
6956 return resultobj;
6957 fail:
6958 return NULL;
6959 }
6960
6961
6962 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6963 PyObject *resultobj;
6964 int arg1 ;
6965 PyObject * obj0 = 0 ;
6966 char *kwnames[] = {
6967 (char *) "milliseconds", NULL
6968 };
6969
6970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6971 {
6972 arg1 = (int)(SWIG_As_int(obj0));
6973 if (SWIG_arg_fail(1)) SWIG_fail;
6974 }
6975 {
6976 PyThreadState* __tstate = wxPyBeginAllowThreads();
6977 wxCaret::SetBlinkTime(arg1);
6978
6979 wxPyEndAllowThreads(__tstate);
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 Py_INCREF(Py_None); resultobj = Py_None;
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6990 PyObject *obj;
6991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6992 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6993 Py_INCREF(obj);
6994 return Py_BuildValue((char *)"");
6995 }
6996 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6997 PyObject *resultobj;
6998 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6999 wxBusyCursor *result;
7000 PyObject * obj0 = 0 ;
7001 char *kwnames[] = {
7002 (char *) "cursor", NULL
7003 };
7004
7005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
7006 if (obj0) {
7007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
7008 if (SWIG_arg_fail(1)) SWIG_fail;
7009 }
7010 {
7011 if (!wxPyCheckForApp()) SWIG_fail;
7012 PyThreadState* __tstate = wxPyBeginAllowThreads();
7013 result = (wxBusyCursor *)new wxBusyCursor(arg1);
7014
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7026 PyObject *resultobj;
7027 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
7028 PyObject * obj0 = 0 ;
7029 char *kwnames[] = {
7030 (char *) "self", NULL
7031 };
7032
7033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
7034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7035 if (SWIG_arg_fail(1)) SWIG_fail;
7036 {
7037 PyThreadState* __tstate = wxPyBeginAllowThreads();
7038 delete arg1;
7039
7040 wxPyEndAllowThreads(__tstate);
7041 if (PyErr_Occurred()) SWIG_fail;
7042 }
7043 Py_INCREF(Py_None); resultobj = Py_None;
7044 return resultobj;
7045 fail:
7046 return NULL;
7047 }
7048
7049
7050 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7051 PyObject *obj;
7052 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7053 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7054 Py_INCREF(obj);
7055 return Py_BuildValue((char *)"");
7056 }
7057 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7058 PyObject *resultobj;
7059 wxWindow *arg1 = (wxWindow *) NULL ;
7060 wxWindowDisabler *result;
7061 PyObject * obj0 = 0 ;
7062 char *kwnames[] = {
7063 (char *) "winToSkip", NULL
7064 };
7065
7066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7067 if (obj0) {
7068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7069 if (SWIG_arg_fail(1)) SWIG_fail;
7070 }
7071 {
7072 if (!wxPyCheckForApp()) SWIG_fail;
7073 PyThreadState* __tstate = wxPyBeginAllowThreads();
7074 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7075
7076 wxPyEndAllowThreads(__tstate);
7077 if (PyErr_Occurred()) SWIG_fail;
7078 }
7079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7080 return resultobj;
7081 fail:
7082 return NULL;
7083 }
7084
7085
7086 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7087 PyObject *resultobj;
7088 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7089 PyObject * obj0 = 0 ;
7090 char *kwnames[] = {
7091 (char *) "self", NULL
7092 };
7093
7094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7096 if (SWIG_arg_fail(1)) SWIG_fail;
7097 {
7098 PyThreadState* __tstate = wxPyBeginAllowThreads();
7099 delete arg1;
7100
7101 wxPyEndAllowThreads(__tstate);
7102 if (PyErr_Occurred()) SWIG_fail;
7103 }
7104 Py_INCREF(Py_None); resultobj = Py_None;
7105 return resultobj;
7106 fail:
7107 return NULL;
7108 }
7109
7110
7111 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7112 PyObject *obj;
7113 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7114 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7115 Py_INCREF(obj);
7116 return Py_BuildValue((char *)"");
7117 }
7118 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7119 PyObject *resultobj;
7120 wxString *arg1 = 0 ;
7121 wxBusyInfo *result;
7122 bool temp1 = false ;
7123 PyObject * obj0 = 0 ;
7124 char *kwnames[] = {
7125 (char *) "message", NULL
7126 };
7127
7128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7129 {
7130 arg1 = wxString_in_helper(obj0);
7131 if (arg1 == NULL) SWIG_fail;
7132 temp1 = true;
7133 }
7134 {
7135 if (!wxPyCheckForApp()) SWIG_fail;
7136 PyThreadState* __tstate = wxPyBeginAllowThreads();
7137 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7138
7139 wxPyEndAllowThreads(__tstate);
7140 if (PyErr_Occurred()) SWIG_fail;
7141 }
7142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7143 {
7144 if (temp1)
7145 delete arg1;
7146 }
7147 return resultobj;
7148 fail:
7149 {
7150 if (temp1)
7151 delete arg1;
7152 }
7153 return NULL;
7154 }
7155
7156
7157 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7158 PyObject *resultobj;
7159 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7160 PyObject * obj0 = 0 ;
7161 char *kwnames[] = {
7162 (char *) "self", NULL
7163 };
7164
7165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7167 if (SWIG_arg_fail(1)) SWIG_fail;
7168 {
7169 PyThreadState* __tstate = wxPyBeginAllowThreads();
7170 delete arg1;
7171
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 Py_INCREF(Py_None); resultobj = Py_None;
7176 return resultobj;
7177 fail:
7178 return NULL;
7179 }
7180
7181
7182 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7183 PyObject *obj;
7184 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7185 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7186 Py_INCREF(obj);
7187 return Py_BuildValue((char *)"");
7188 }
7189 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7190 PyObject *resultobj;
7191 wxStopWatch *result;
7192 char *kwnames[] = {
7193 NULL
7194 };
7195
7196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7197 {
7198 PyThreadState* __tstate = wxPyBeginAllowThreads();
7199 result = (wxStopWatch *)new wxStopWatch();
7200
7201 wxPyEndAllowThreads(__tstate);
7202 if (PyErr_Occurred()) SWIG_fail;
7203 }
7204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7205 return resultobj;
7206 fail:
7207 return NULL;
7208 }
7209
7210
7211 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7212 PyObject *resultobj;
7213 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7214 long arg2 = (long) 0 ;
7215 PyObject * obj0 = 0 ;
7216 PyObject * obj1 = 0 ;
7217 char *kwnames[] = {
7218 (char *) "self",(char *) "t0", NULL
7219 };
7220
7221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7223 if (SWIG_arg_fail(1)) SWIG_fail;
7224 if (obj1) {
7225 {
7226 arg2 = (long)(SWIG_As_long(obj1));
7227 if (SWIG_arg_fail(2)) SWIG_fail;
7228 }
7229 }
7230 {
7231 PyThreadState* __tstate = wxPyBeginAllowThreads();
7232 (arg1)->Start(arg2);
7233
7234 wxPyEndAllowThreads(__tstate);
7235 if (PyErr_Occurred()) SWIG_fail;
7236 }
7237 Py_INCREF(Py_None); resultobj = Py_None;
7238 return resultobj;
7239 fail:
7240 return NULL;
7241 }
7242
7243
7244 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7245 PyObject *resultobj;
7246 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7247 PyObject * obj0 = 0 ;
7248 char *kwnames[] = {
7249 (char *) "self", NULL
7250 };
7251
7252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7254 if (SWIG_arg_fail(1)) SWIG_fail;
7255 {
7256 PyThreadState* __tstate = wxPyBeginAllowThreads();
7257 (arg1)->Pause();
7258
7259 wxPyEndAllowThreads(__tstate);
7260 if (PyErr_Occurred()) SWIG_fail;
7261 }
7262 Py_INCREF(Py_None); resultobj = Py_None;
7263 return resultobj;
7264 fail:
7265 return NULL;
7266 }
7267
7268
7269 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7270 PyObject *resultobj;
7271 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7272 PyObject * obj0 = 0 ;
7273 char *kwnames[] = {
7274 (char *) "self", NULL
7275 };
7276
7277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7279 if (SWIG_arg_fail(1)) SWIG_fail;
7280 {
7281 PyThreadState* __tstate = wxPyBeginAllowThreads();
7282 (arg1)->Resume();
7283
7284 wxPyEndAllowThreads(__tstate);
7285 if (PyErr_Occurred()) SWIG_fail;
7286 }
7287 Py_INCREF(Py_None); resultobj = Py_None;
7288 return resultobj;
7289 fail:
7290 return NULL;
7291 }
7292
7293
7294 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7295 PyObject *resultobj;
7296 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7297 long result;
7298 PyObject * obj0 = 0 ;
7299 char *kwnames[] = {
7300 (char *) "self", NULL
7301 };
7302
7303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7305 if (SWIG_arg_fail(1)) SWIG_fail;
7306 {
7307 PyThreadState* __tstate = wxPyBeginAllowThreads();
7308 result = (long)((wxStopWatch const *)arg1)->Time();
7309
7310 wxPyEndAllowThreads(__tstate);
7311 if (PyErr_Occurred()) SWIG_fail;
7312 }
7313 {
7314 resultobj = SWIG_From_long((long)(result));
7315 }
7316 return resultobj;
7317 fail:
7318 return NULL;
7319 }
7320
7321
7322 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7323 PyObject *obj;
7324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7325 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7326 Py_INCREF(obj);
7327 return Py_BuildValue((char *)"");
7328 }
7329 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7330 PyObject *resultobj;
7331 int arg1 = (int) 9 ;
7332 int arg2 = (int) wxID_FILE1 ;
7333 wxFileHistory *result;
7334 PyObject * obj0 = 0 ;
7335 PyObject * obj1 = 0 ;
7336 char *kwnames[] = {
7337 (char *) "maxFiles",(char *) "idBase", NULL
7338 };
7339
7340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7341 if (obj0) {
7342 {
7343 arg1 = (int)(SWIG_As_int(obj0));
7344 if (SWIG_arg_fail(1)) SWIG_fail;
7345 }
7346 }
7347 if (obj1) {
7348 {
7349 arg2 = (int)(SWIG_As_int(obj1));
7350 if (SWIG_arg_fail(2)) SWIG_fail;
7351 }
7352 }
7353 {
7354 PyThreadState* __tstate = wxPyBeginAllowThreads();
7355 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7356
7357 wxPyEndAllowThreads(__tstate);
7358 if (PyErr_Occurred()) SWIG_fail;
7359 }
7360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7361 return resultobj;
7362 fail:
7363 return NULL;
7364 }
7365
7366
7367 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7368 PyObject *resultobj;
7369 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7370 PyObject * obj0 = 0 ;
7371 char *kwnames[] = {
7372 (char *) "self", NULL
7373 };
7374
7375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7377 if (SWIG_arg_fail(1)) SWIG_fail;
7378 {
7379 PyThreadState* __tstate = wxPyBeginAllowThreads();
7380 delete arg1;
7381
7382 wxPyEndAllowThreads(__tstate);
7383 if (PyErr_Occurred()) SWIG_fail;
7384 }
7385 Py_INCREF(Py_None); resultobj = Py_None;
7386 return resultobj;
7387 fail:
7388 return NULL;
7389 }
7390
7391
7392 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7393 PyObject *resultobj;
7394 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7395 wxString *arg2 = 0 ;
7396 bool temp2 = false ;
7397 PyObject * obj0 = 0 ;
7398 PyObject * obj1 = 0 ;
7399 char *kwnames[] = {
7400 (char *) "self",(char *) "file", NULL
7401 };
7402
7403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7405 if (SWIG_arg_fail(1)) SWIG_fail;
7406 {
7407 arg2 = wxString_in_helper(obj1);
7408 if (arg2 == NULL) SWIG_fail;
7409 temp2 = true;
7410 }
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 (arg1)->AddFileToHistory((wxString const &)*arg2);
7414
7415 wxPyEndAllowThreads(__tstate);
7416 if (PyErr_Occurred()) SWIG_fail;
7417 }
7418 Py_INCREF(Py_None); resultobj = Py_None;
7419 {
7420 if (temp2)
7421 delete arg2;
7422 }
7423 return resultobj;
7424 fail:
7425 {
7426 if (temp2)
7427 delete arg2;
7428 }
7429 return NULL;
7430 }
7431
7432
7433 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7434 PyObject *resultobj;
7435 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7436 int arg2 ;
7437 PyObject * obj0 = 0 ;
7438 PyObject * obj1 = 0 ;
7439 char *kwnames[] = {
7440 (char *) "self",(char *) "i", NULL
7441 };
7442
7443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7445 if (SWIG_arg_fail(1)) SWIG_fail;
7446 {
7447 arg2 = (int)(SWIG_As_int(obj1));
7448 if (SWIG_arg_fail(2)) SWIG_fail;
7449 }
7450 {
7451 PyThreadState* __tstate = wxPyBeginAllowThreads();
7452 (arg1)->RemoveFileFromHistory(arg2);
7453
7454 wxPyEndAllowThreads(__tstate);
7455 if (PyErr_Occurred()) SWIG_fail;
7456 }
7457 Py_INCREF(Py_None); resultobj = Py_None;
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7465 PyObject *resultobj;
7466 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7467 int result;
7468 PyObject * obj0 = 0 ;
7469 char *kwnames[] = {
7470 (char *) "self", NULL
7471 };
7472
7473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7475 if (SWIG_arg_fail(1)) SWIG_fail;
7476 {
7477 PyThreadState* __tstate = wxPyBeginAllowThreads();
7478 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7479
7480 wxPyEndAllowThreads(__tstate);
7481 if (PyErr_Occurred()) SWIG_fail;
7482 }
7483 {
7484 resultobj = SWIG_From_int((int)(result));
7485 }
7486 return resultobj;
7487 fail:
7488 return NULL;
7489 }
7490
7491
7492 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7493 PyObject *resultobj;
7494 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7495 wxMenu *arg2 = (wxMenu *) 0 ;
7496 PyObject * obj0 = 0 ;
7497 PyObject * obj1 = 0 ;
7498 char *kwnames[] = {
7499 (char *) "self",(char *) "menu", NULL
7500 };
7501
7502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7504 if (SWIG_arg_fail(1)) SWIG_fail;
7505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7506 if (SWIG_arg_fail(2)) SWIG_fail;
7507 {
7508 PyThreadState* __tstate = wxPyBeginAllowThreads();
7509 (arg1)->UseMenu(arg2);
7510
7511 wxPyEndAllowThreads(__tstate);
7512 if (PyErr_Occurred()) SWIG_fail;
7513 }
7514 Py_INCREF(Py_None); resultobj = Py_None;
7515 return resultobj;
7516 fail:
7517 return NULL;
7518 }
7519
7520
7521 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7522 PyObject *resultobj;
7523 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7524 wxMenu *arg2 = (wxMenu *) 0 ;
7525 PyObject * obj0 = 0 ;
7526 PyObject * obj1 = 0 ;
7527 char *kwnames[] = {
7528 (char *) "self",(char *) "menu", NULL
7529 };
7530
7531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7533 if (SWIG_arg_fail(1)) SWIG_fail;
7534 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7535 if (SWIG_arg_fail(2)) SWIG_fail;
7536 {
7537 PyThreadState* __tstate = wxPyBeginAllowThreads();
7538 (arg1)->RemoveMenu(arg2);
7539
7540 wxPyEndAllowThreads(__tstate);
7541 if (PyErr_Occurred()) SWIG_fail;
7542 }
7543 Py_INCREF(Py_None); resultobj = Py_None;
7544 return resultobj;
7545 fail:
7546 return NULL;
7547 }
7548
7549
7550 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7551 PyObject *resultobj;
7552 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7553 wxConfigBase *arg2 = 0 ;
7554 PyObject * obj0 = 0 ;
7555 PyObject * obj1 = 0 ;
7556 char *kwnames[] = {
7557 (char *) "self",(char *) "config", NULL
7558 };
7559
7560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7562 if (SWIG_arg_fail(1)) SWIG_fail;
7563 {
7564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7565 if (SWIG_arg_fail(2)) SWIG_fail;
7566 if (arg2 == NULL) {
7567 SWIG_null_ref("wxConfigBase");
7568 }
7569 if (SWIG_arg_fail(2)) SWIG_fail;
7570 }
7571 {
7572 PyThreadState* __tstate = wxPyBeginAllowThreads();
7573 (arg1)->Load(*arg2);
7574
7575 wxPyEndAllowThreads(__tstate);
7576 if (PyErr_Occurred()) SWIG_fail;
7577 }
7578 Py_INCREF(Py_None); resultobj = Py_None;
7579 return resultobj;
7580 fail:
7581 return NULL;
7582 }
7583
7584
7585 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7586 PyObject *resultobj;
7587 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7588 wxConfigBase *arg2 = 0 ;
7589 PyObject * obj0 = 0 ;
7590 PyObject * obj1 = 0 ;
7591 char *kwnames[] = {
7592 (char *) "self",(char *) "config", NULL
7593 };
7594
7595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7597 if (SWIG_arg_fail(1)) SWIG_fail;
7598 {
7599 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7600 if (SWIG_arg_fail(2)) SWIG_fail;
7601 if (arg2 == NULL) {
7602 SWIG_null_ref("wxConfigBase");
7603 }
7604 if (SWIG_arg_fail(2)) SWIG_fail;
7605 }
7606 {
7607 PyThreadState* __tstate = wxPyBeginAllowThreads();
7608 (arg1)->Save(*arg2);
7609
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 Py_INCREF(Py_None); resultobj = Py_None;
7614 return resultobj;
7615 fail:
7616 return NULL;
7617 }
7618
7619
7620 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7621 PyObject *resultobj;
7622 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7623 PyObject * obj0 = 0 ;
7624 char *kwnames[] = {
7625 (char *) "self", NULL
7626 };
7627
7628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7630 if (SWIG_arg_fail(1)) SWIG_fail;
7631 {
7632 PyThreadState* __tstate = wxPyBeginAllowThreads();
7633 (arg1)->AddFilesToMenu();
7634
7635 wxPyEndAllowThreads(__tstate);
7636 if (PyErr_Occurred()) SWIG_fail;
7637 }
7638 Py_INCREF(Py_None); resultobj = Py_None;
7639 return resultobj;
7640 fail:
7641 return NULL;
7642 }
7643
7644
7645 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7646 PyObject *resultobj;
7647 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7648 wxMenu *arg2 = (wxMenu *) 0 ;
7649 PyObject * obj0 = 0 ;
7650 PyObject * obj1 = 0 ;
7651 char *kwnames[] = {
7652 (char *) "self",(char *) "menu", NULL
7653 };
7654
7655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7657 if (SWIG_arg_fail(1)) SWIG_fail;
7658 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7659 if (SWIG_arg_fail(2)) SWIG_fail;
7660 {
7661 PyThreadState* __tstate = wxPyBeginAllowThreads();
7662 (arg1)->AddFilesToMenu(arg2);
7663
7664 wxPyEndAllowThreads(__tstate);
7665 if (PyErr_Occurred()) SWIG_fail;
7666 }
7667 Py_INCREF(Py_None); resultobj = Py_None;
7668 return resultobj;
7669 fail:
7670 return NULL;
7671 }
7672
7673
7674 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7675 PyObject *resultobj;
7676 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7677 int arg2 ;
7678 wxString result;
7679 PyObject * obj0 = 0 ;
7680 PyObject * obj1 = 0 ;
7681 char *kwnames[] = {
7682 (char *) "self",(char *) "i", NULL
7683 };
7684
7685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7687 if (SWIG_arg_fail(1)) SWIG_fail;
7688 {
7689 arg2 = (int)(SWIG_As_int(obj1));
7690 if (SWIG_arg_fail(2)) SWIG_fail;
7691 }
7692 {
7693 PyThreadState* __tstate = wxPyBeginAllowThreads();
7694 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7695
7696 wxPyEndAllowThreads(__tstate);
7697 if (PyErr_Occurred()) SWIG_fail;
7698 }
7699 {
7700 #if wxUSE_UNICODE
7701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7702 #else
7703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7704 #endif
7705 }
7706 return resultobj;
7707 fail:
7708 return NULL;
7709 }
7710
7711
7712 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7713 PyObject *resultobj;
7714 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7715 int result;
7716 PyObject * obj0 = 0 ;
7717 char *kwnames[] = {
7718 (char *) "self", NULL
7719 };
7720
7721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7723 if (SWIG_arg_fail(1)) SWIG_fail;
7724 {
7725 PyThreadState* __tstate = wxPyBeginAllowThreads();
7726 result = (int)((wxFileHistory const *)arg1)->GetCount();
7727
7728 wxPyEndAllowThreads(__tstate);
7729 if (PyErr_Occurred()) SWIG_fail;
7730 }
7731 {
7732 resultobj = SWIG_From_int((int)(result));
7733 }
7734 return resultobj;
7735 fail:
7736 return NULL;
7737 }
7738
7739
7740 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7741 PyObject *obj;
7742 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7743 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7744 Py_INCREF(obj);
7745 return Py_BuildValue((char *)"");
7746 }
7747 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7748 PyObject *resultobj;
7749 wxString *arg1 = 0 ;
7750 wxString const &arg2_defvalue = wxPyEmptyString ;
7751 wxString *arg2 = (wxString *) &arg2_defvalue ;
7752 wxSingleInstanceChecker *result;
7753 bool temp1 = false ;
7754 bool temp2 = false ;
7755 PyObject * obj0 = 0 ;
7756 PyObject * obj1 = 0 ;
7757 char *kwnames[] = {
7758 (char *) "name",(char *) "path", NULL
7759 };
7760
7761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7762 {
7763 arg1 = wxString_in_helper(obj0);
7764 if (arg1 == NULL) SWIG_fail;
7765 temp1 = true;
7766 }
7767 if (obj1) {
7768 {
7769 arg2 = wxString_in_helper(obj1);
7770 if (arg2 == NULL) SWIG_fail;
7771 temp2 = true;
7772 }
7773 }
7774 {
7775 PyThreadState* __tstate = wxPyBeginAllowThreads();
7776 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7777
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7782 {
7783 if (temp1)
7784 delete arg1;
7785 }
7786 {
7787 if (temp2)
7788 delete arg2;
7789 }
7790 return resultobj;
7791 fail:
7792 {
7793 if (temp1)
7794 delete arg1;
7795 }
7796 {
7797 if (temp2)
7798 delete arg2;
7799 }
7800 return NULL;
7801 }
7802
7803
7804 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7805 PyObject *resultobj;
7806 wxSingleInstanceChecker *result;
7807 char *kwnames[] = {
7808 NULL
7809 };
7810
7811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7812 {
7813 PyThreadState* __tstate = wxPyBeginAllowThreads();
7814 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7815
7816 wxPyEndAllowThreads(__tstate);
7817 if (PyErr_Occurred()) SWIG_fail;
7818 }
7819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7820 return resultobj;
7821 fail:
7822 return NULL;
7823 }
7824
7825
7826 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7827 PyObject *resultobj;
7828 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7829 PyObject * obj0 = 0 ;
7830 char *kwnames[] = {
7831 (char *) "self", NULL
7832 };
7833
7834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7836 if (SWIG_arg_fail(1)) SWIG_fail;
7837 {
7838 PyThreadState* __tstate = wxPyBeginAllowThreads();
7839 delete arg1;
7840
7841 wxPyEndAllowThreads(__tstate);
7842 if (PyErr_Occurred()) SWIG_fail;
7843 }
7844 Py_INCREF(Py_None); resultobj = Py_None;
7845 return resultobj;
7846 fail:
7847 return NULL;
7848 }
7849
7850
7851 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7852 PyObject *resultobj;
7853 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7854 wxString *arg2 = 0 ;
7855 wxString const &arg3_defvalue = wxPyEmptyString ;
7856 wxString *arg3 = (wxString *) &arg3_defvalue ;
7857 bool result;
7858 bool temp2 = false ;
7859 bool temp3 = false ;
7860 PyObject * obj0 = 0 ;
7861 PyObject * obj1 = 0 ;
7862 PyObject * obj2 = 0 ;
7863 char *kwnames[] = {
7864 (char *) "self",(char *) "name",(char *) "path", NULL
7865 };
7866
7867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7869 if (SWIG_arg_fail(1)) SWIG_fail;
7870 {
7871 arg2 = wxString_in_helper(obj1);
7872 if (arg2 == NULL) SWIG_fail;
7873 temp2 = true;
7874 }
7875 if (obj2) {
7876 {
7877 arg3 = wxString_in_helper(obj2);
7878 if (arg3 == NULL) SWIG_fail;
7879 temp3 = true;
7880 }
7881 }
7882 {
7883 PyThreadState* __tstate = wxPyBeginAllowThreads();
7884 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7885
7886 wxPyEndAllowThreads(__tstate);
7887 if (PyErr_Occurred()) SWIG_fail;
7888 }
7889 {
7890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7891 }
7892 {
7893 if (temp2)
7894 delete arg2;
7895 }
7896 {
7897 if (temp3)
7898 delete arg3;
7899 }
7900 return resultobj;
7901 fail:
7902 {
7903 if (temp2)
7904 delete arg2;
7905 }
7906 {
7907 if (temp3)
7908 delete arg3;
7909 }
7910 return NULL;
7911 }
7912
7913
7914 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7915 PyObject *resultobj;
7916 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7917 bool result;
7918 PyObject * obj0 = 0 ;
7919 char *kwnames[] = {
7920 (char *) "self", NULL
7921 };
7922
7923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7925 if (SWIG_arg_fail(1)) SWIG_fail;
7926 {
7927 PyThreadState* __tstate = wxPyBeginAllowThreads();
7928 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7929
7930 wxPyEndAllowThreads(__tstate);
7931 if (PyErr_Occurred()) SWIG_fail;
7932 }
7933 {
7934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7935 }
7936 return resultobj;
7937 fail:
7938 return NULL;
7939 }
7940
7941
7942 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7943 PyObject *obj;
7944 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7945 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7946 Py_INCREF(obj);
7947 return Py_BuildValue((char *)"");
7948 }
7949 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7950 PyObject *resultobj;
7951 wxWindow *arg1 = (wxWindow *) 0 ;
7952 wxDC *arg2 = 0 ;
7953 bool result;
7954 PyObject * obj0 = 0 ;
7955 PyObject * obj1 = 0 ;
7956 char *kwnames[] = {
7957 (char *) "window",(char *) "dc", NULL
7958 };
7959
7960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7962 if (SWIG_arg_fail(1)) SWIG_fail;
7963 {
7964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7965 if (SWIG_arg_fail(2)) SWIG_fail;
7966 if (arg2 == NULL) {
7967 SWIG_null_ref("wxDC");
7968 }
7969 if (SWIG_arg_fail(2)) SWIG_fail;
7970 }
7971 {
7972 PyThreadState* __tstate = wxPyBeginAllowThreads();
7973 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7974
7975 wxPyEndAllowThreads(__tstate);
7976 if (PyErr_Occurred()) SWIG_fail;
7977 }
7978 {
7979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7980 }
7981 return resultobj;
7982 fail:
7983 return NULL;
7984 }
7985
7986
7987 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7988 PyObject *resultobj;
7989 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7990 PyObject * obj0 = 0 ;
7991 char *kwnames[] = {
7992 (char *) "self", NULL
7993 };
7994
7995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7997 if (SWIG_arg_fail(1)) SWIG_fail;
7998 {
7999 PyThreadState* __tstate = wxPyBeginAllowThreads();
8000 delete arg1;
8001
8002 wxPyEndAllowThreads(__tstate);
8003 if (PyErr_Occurred()) SWIG_fail;
8004 }
8005 Py_INCREF(Py_None); resultobj = Py_None;
8006 return resultobj;
8007 fail:
8008 return NULL;
8009 }
8010
8011
8012 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
8013 PyObject *resultobj;
8014 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8015 wxString result;
8016 PyObject * obj0 = 0 ;
8017 char *kwnames[] = {
8018 (char *) "self", NULL
8019 };
8020
8021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
8022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8023 if (SWIG_arg_fail(1)) SWIG_fail;
8024 {
8025 PyThreadState* __tstate = wxPyBeginAllowThreads();
8026 result = (arg1)->GetTip();
8027
8028 wxPyEndAllowThreads(__tstate);
8029 if (PyErr_Occurred()) SWIG_fail;
8030 }
8031 {
8032 #if wxUSE_UNICODE
8033 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8034 #else
8035 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8036 #endif
8037 }
8038 return resultobj;
8039 fail:
8040 return NULL;
8041 }
8042
8043
8044 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8045 PyObject *resultobj;
8046 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8047 size_t result;
8048 PyObject * obj0 = 0 ;
8049 char *kwnames[] = {
8050 (char *) "self", NULL
8051 };
8052
8053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8055 if (SWIG_arg_fail(1)) SWIG_fail;
8056 {
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 result = (size_t)(arg1)->GetCurrentTip();
8059
8060 wxPyEndAllowThreads(__tstate);
8061 if (PyErr_Occurred()) SWIG_fail;
8062 }
8063 {
8064 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8065 }
8066 return resultobj;
8067 fail:
8068 return NULL;
8069 }
8070
8071
8072 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8073 PyObject *resultobj;
8074 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8075 wxString *arg2 = 0 ;
8076 wxString result;
8077 bool temp2 = false ;
8078 PyObject * obj0 = 0 ;
8079 PyObject * obj1 = 0 ;
8080 char *kwnames[] = {
8081 (char *) "self",(char *) "tip", NULL
8082 };
8083
8084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8086 if (SWIG_arg_fail(1)) SWIG_fail;
8087 {
8088 arg2 = wxString_in_helper(obj1);
8089 if (arg2 == NULL) SWIG_fail;
8090 temp2 = true;
8091 }
8092 {
8093 PyThreadState* __tstate = wxPyBeginAllowThreads();
8094 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8095
8096 wxPyEndAllowThreads(__tstate);
8097 if (PyErr_Occurred()) SWIG_fail;
8098 }
8099 {
8100 #if wxUSE_UNICODE
8101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8102 #else
8103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8104 #endif
8105 }
8106 {
8107 if (temp2)
8108 delete arg2;
8109 }
8110 return resultobj;
8111 fail:
8112 {
8113 if (temp2)
8114 delete arg2;
8115 }
8116 return NULL;
8117 }
8118
8119
8120 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8121 PyObject *obj;
8122 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8123 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8124 Py_INCREF(obj);
8125 return Py_BuildValue((char *)"");
8126 }
8127 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8128 PyObject *resultobj;
8129 size_t arg1 ;
8130 wxPyTipProvider *result;
8131 PyObject * obj0 = 0 ;
8132 char *kwnames[] = {
8133 (char *) "currentTip", NULL
8134 };
8135
8136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8137 {
8138 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8139 if (SWIG_arg_fail(1)) SWIG_fail;
8140 }
8141 {
8142 PyThreadState* __tstate = wxPyBeginAllowThreads();
8143 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8144
8145 wxPyEndAllowThreads(__tstate);
8146 if (PyErr_Occurred()) SWIG_fail;
8147 }
8148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8149 return resultobj;
8150 fail:
8151 return NULL;
8152 }
8153
8154
8155 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8156 PyObject *resultobj;
8157 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8158 PyObject *arg2 = (PyObject *) 0 ;
8159 PyObject *arg3 = (PyObject *) 0 ;
8160 PyObject * obj0 = 0 ;
8161 PyObject * obj1 = 0 ;
8162 PyObject * obj2 = 0 ;
8163 char *kwnames[] = {
8164 (char *) "self",(char *) "self",(char *) "_class", NULL
8165 };
8166
8167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8169 if (SWIG_arg_fail(1)) SWIG_fail;
8170 arg2 = obj1;
8171 arg3 = obj2;
8172 {
8173 PyThreadState* __tstate = wxPyBeginAllowThreads();
8174 (arg1)->_setCallbackInfo(arg2,arg3);
8175
8176 wxPyEndAllowThreads(__tstate);
8177 if (PyErr_Occurred()) SWIG_fail;
8178 }
8179 Py_INCREF(Py_None); resultobj = Py_None;
8180 return resultobj;
8181 fail:
8182 return NULL;
8183 }
8184
8185
8186 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8187 PyObject *obj;
8188 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8189 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8190 Py_INCREF(obj);
8191 return Py_BuildValue((char *)"");
8192 }
8193 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8194 PyObject *resultobj;
8195 wxWindow *arg1 = (wxWindow *) 0 ;
8196 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8197 bool arg3 = (bool) true ;
8198 bool result;
8199 PyObject * obj0 = 0 ;
8200 PyObject * obj1 = 0 ;
8201 PyObject * obj2 = 0 ;
8202 char *kwnames[] = {
8203 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8204 };
8205
8206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8208 if (SWIG_arg_fail(1)) SWIG_fail;
8209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8210 if (SWIG_arg_fail(2)) SWIG_fail;
8211 if (obj2) {
8212 {
8213 arg3 = (bool)(SWIG_As_bool(obj2));
8214 if (SWIG_arg_fail(3)) SWIG_fail;
8215 }
8216 }
8217 {
8218 if (!wxPyCheckForApp()) SWIG_fail;
8219 PyThreadState* __tstate = wxPyBeginAllowThreads();
8220 result = (bool)wxShowTip(arg1,arg2,arg3);
8221
8222 wxPyEndAllowThreads(__tstate);
8223 if (PyErr_Occurred()) SWIG_fail;
8224 }
8225 {
8226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8227 }
8228 return resultobj;
8229 fail:
8230 return NULL;
8231 }
8232
8233
8234 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8235 PyObject *resultobj;
8236 wxString *arg1 = 0 ;
8237 size_t arg2 ;
8238 wxTipProvider *result;
8239 bool temp1 = false ;
8240 PyObject * obj0 = 0 ;
8241 PyObject * obj1 = 0 ;
8242 char *kwnames[] = {
8243 (char *) "filename",(char *) "currentTip", NULL
8244 };
8245
8246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8247 {
8248 arg1 = wxString_in_helper(obj0);
8249 if (arg1 == NULL) SWIG_fail;
8250 temp1 = true;
8251 }
8252 {
8253 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8254 if (SWIG_arg_fail(2)) SWIG_fail;
8255 }
8256 {
8257 if (!wxPyCheckForApp()) SWIG_fail;
8258 PyThreadState* __tstate = wxPyBeginAllowThreads();
8259 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8260
8261 wxPyEndAllowThreads(__tstate);
8262 if (PyErr_Occurred()) SWIG_fail;
8263 }
8264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8265 {
8266 if (temp1)
8267 delete arg1;
8268 }
8269 return resultobj;
8270 fail:
8271 {
8272 if (temp1)
8273 delete arg1;
8274 }
8275 return NULL;
8276 }
8277
8278
8279 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8280 PyObject *resultobj;
8281 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8282 int arg2 = (int) -1 ;
8283 wxPyTimer *result;
8284 PyObject * obj0 = 0 ;
8285 PyObject * obj1 = 0 ;
8286 char *kwnames[] = {
8287 (char *) "owner",(char *) "id", NULL
8288 };
8289
8290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8291 if (obj0) {
8292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8293 if (SWIG_arg_fail(1)) SWIG_fail;
8294 }
8295 if (obj1) {
8296 {
8297 arg2 = (int)(SWIG_As_int(obj1));
8298 if (SWIG_arg_fail(2)) SWIG_fail;
8299 }
8300 }
8301 {
8302 if (!wxPyCheckForApp()) SWIG_fail;
8303 PyThreadState* __tstate = wxPyBeginAllowThreads();
8304 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8305
8306 wxPyEndAllowThreads(__tstate);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8310 return resultobj;
8311 fail:
8312 return NULL;
8313 }
8314
8315
8316 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8317 PyObject *resultobj;
8318 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8319 PyObject * obj0 = 0 ;
8320 char *kwnames[] = {
8321 (char *) "self", NULL
8322 };
8323
8324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8326 if (SWIG_arg_fail(1)) SWIG_fail;
8327 {
8328 PyThreadState* __tstate = wxPyBeginAllowThreads();
8329 delete arg1;
8330
8331 wxPyEndAllowThreads(__tstate);
8332 if (PyErr_Occurred()) SWIG_fail;
8333 }
8334 Py_INCREF(Py_None); resultobj = Py_None;
8335 return resultobj;
8336 fail:
8337 return NULL;
8338 }
8339
8340
8341 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8342 PyObject *resultobj;
8343 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8344 PyObject *arg2 = (PyObject *) 0 ;
8345 PyObject *arg3 = (PyObject *) 0 ;
8346 int arg4 = (int) 1 ;
8347 PyObject * obj0 = 0 ;
8348 PyObject * obj1 = 0 ;
8349 PyObject * obj2 = 0 ;
8350 PyObject * obj3 = 0 ;
8351 char *kwnames[] = {
8352 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8353 };
8354
8355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8357 if (SWIG_arg_fail(1)) SWIG_fail;
8358 arg2 = obj1;
8359 arg3 = obj2;
8360 if (obj3) {
8361 {
8362 arg4 = (int)(SWIG_As_int(obj3));
8363 if (SWIG_arg_fail(4)) SWIG_fail;
8364 }
8365 }
8366 {
8367 PyThreadState* __tstate = wxPyBeginAllowThreads();
8368 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8369
8370 wxPyEndAllowThreads(__tstate);
8371 if (PyErr_Occurred()) SWIG_fail;
8372 }
8373 Py_INCREF(Py_None); resultobj = Py_None;
8374 return resultobj;
8375 fail:
8376 return NULL;
8377 }
8378
8379
8380 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8381 PyObject *resultobj;
8382 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8383 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8384 int arg3 = (int) -1 ;
8385 PyObject * obj0 = 0 ;
8386 PyObject * obj1 = 0 ;
8387 PyObject * obj2 = 0 ;
8388 char *kwnames[] = {
8389 (char *) "self",(char *) "owner",(char *) "id", NULL
8390 };
8391
8392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8394 if (SWIG_arg_fail(1)) SWIG_fail;
8395 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8396 if (SWIG_arg_fail(2)) SWIG_fail;
8397 if (obj2) {
8398 {
8399 arg3 = (int)(SWIG_As_int(obj2));
8400 if (SWIG_arg_fail(3)) SWIG_fail;
8401 }
8402 }
8403 {
8404 PyThreadState* __tstate = wxPyBeginAllowThreads();
8405 (arg1)->SetOwner(arg2,arg3);
8406
8407 wxPyEndAllowThreads(__tstate);
8408 if (PyErr_Occurred()) SWIG_fail;
8409 }
8410 Py_INCREF(Py_None); resultobj = Py_None;
8411 return resultobj;
8412 fail:
8413 return NULL;
8414 }
8415
8416
8417 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8418 PyObject *resultobj;
8419 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8420 wxEvtHandler *result;
8421 PyObject * obj0 = 0 ;
8422 char *kwnames[] = {
8423 (char *) "self", NULL
8424 };
8425
8426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8428 if (SWIG_arg_fail(1)) SWIG_fail;
8429 {
8430 PyThreadState* __tstate = wxPyBeginAllowThreads();
8431 result = (wxEvtHandler *)(arg1)->GetOwner();
8432
8433 wxPyEndAllowThreads(__tstate);
8434 if (PyErr_Occurred()) SWIG_fail;
8435 }
8436 {
8437 resultobj = wxPyMake_wxObject(result, 0);
8438 }
8439 return resultobj;
8440 fail:
8441 return NULL;
8442 }
8443
8444
8445 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8446 PyObject *resultobj;
8447 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8448 int arg2 = (int) -1 ;
8449 bool arg3 = (bool) false ;
8450 bool result;
8451 PyObject * obj0 = 0 ;
8452 PyObject * obj1 = 0 ;
8453 PyObject * obj2 = 0 ;
8454 char *kwnames[] = {
8455 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8456 };
8457
8458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8460 if (SWIG_arg_fail(1)) SWIG_fail;
8461 if (obj1) {
8462 {
8463 arg2 = (int)(SWIG_As_int(obj1));
8464 if (SWIG_arg_fail(2)) SWIG_fail;
8465 }
8466 }
8467 if (obj2) {
8468 {
8469 arg3 = (bool)(SWIG_As_bool(obj2));
8470 if (SWIG_arg_fail(3)) SWIG_fail;
8471 }
8472 }
8473 {
8474 PyThreadState* __tstate = wxPyBeginAllowThreads();
8475 result = (bool)(arg1)->Start(arg2,arg3);
8476
8477 wxPyEndAllowThreads(__tstate);
8478 if (PyErr_Occurred()) SWIG_fail;
8479 }
8480 {
8481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8482 }
8483 return resultobj;
8484 fail:
8485 return NULL;
8486 }
8487
8488
8489 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8490 PyObject *resultobj;
8491 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8492 PyObject * obj0 = 0 ;
8493 char *kwnames[] = {
8494 (char *) "self", NULL
8495 };
8496
8497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8499 if (SWIG_arg_fail(1)) SWIG_fail;
8500 {
8501 PyThreadState* __tstate = wxPyBeginAllowThreads();
8502 (arg1)->Stop();
8503
8504 wxPyEndAllowThreads(__tstate);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 Py_INCREF(Py_None); resultobj = Py_None;
8508 return resultobj;
8509 fail:
8510 return NULL;
8511 }
8512
8513
8514 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8515 PyObject *resultobj;
8516 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8517 bool result;
8518 PyObject * obj0 = 0 ;
8519 char *kwnames[] = {
8520 (char *) "self", NULL
8521 };
8522
8523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8525 if (SWIG_arg_fail(1)) SWIG_fail;
8526 {
8527 PyThreadState* __tstate = wxPyBeginAllowThreads();
8528 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8529
8530 wxPyEndAllowThreads(__tstate);
8531 if (PyErr_Occurred()) SWIG_fail;
8532 }
8533 {
8534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8535 }
8536 return resultobj;
8537 fail:
8538 return NULL;
8539 }
8540
8541
8542 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8543 PyObject *resultobj;
8544 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8545 int result;
8546 PyObject * obj0 = 0 ;
8547 char *kwnames[] = {
8548 (char *) "self", NULL
8549 };
8550
8551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8553 if (SWIG_arg_fail(1)) SWIG_fail;
8554 {
8555 PyThreadState* __tstate = wxPyBeginAllowThreads();
8556 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8557
8558 wxPyEndAllowThreads(__tstate);
8559 if (PyErr_Occurred()) SWIG_fail;
8560 }
8561 {
8562 resultobj = SWIG_From_int((int)(result));
8563 }
8564 return resultobj;
8565 fail:
8566 return NULL;
8567 }
8568
8569
8570 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8571 PyObject *resultobj;
8572 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8573 bool result;
8574 PyObject * obj0 = 0 ;
8575 char *kwnames[] = {
8576 (char *) "self", NULL
8577 };
8578
8579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8581 if (SWIG_arg_fail(1)) SWIG_fail;
8582 {
8583 PyThreadState* __tstate = wxPyBeginAllowThreads();
8584 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8585
8586 wxPyEndAllowThreads(__tstate);
8587 if (PyErr_Occurred()) SWIG_fail;
8588 }
8589 {
8590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8591 }
8592 return resultobj;
8593 fail:
8594 return NULL;
8595 }
8596
8597
8598 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8599 PyObject *resultobj;
8600 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8601 int result;
8602 PyObject * obj0 = 0 ;
8603 char *kwnames[] = {
8604 (char *) "self", NULL
8605 };
8606
8607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8609 if (SWIG_arg_fail(1)) SWIG_fail;
8610 {
8611 PyThreadState* __tstate = wxPyBeginAllowThreads();
8612 result = (int)((wxPyTimer const *)arg1)->GetId();
8613
8614 wxPyEndAllowThreads(__tstate);
8615 if (PyErr_Occurred()) SWIG_fail;
8616 }
8617 {
8618 resultobj = SWIG_From_int((int)(result));
8619 }
8620 return resultobj;
8621 fail:
8622 return NULL;
8623 }
8624
8625
8626 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8627 PyObject *obj;
8628 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8629 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8630 Py_INCREF(obj);
8631 return Py_BuildValue((char *)"");
8632 }
8633 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8634 PyObject *resultobj;
8635 int arg1 = (int) 0 ;
8636 int arg2 = (int) 0 ;
8637 wxTimerEvent *result;
8638 PyObject * obj0 = 0 ;
8639 PyObject * obj1 = 0 ;
8640 char *kwnames[] = {
8641 (char *) "timerid",(char *) "interval", NULL
8642 };
8643
8644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8645 if (obj0) {
8646 {
8647 arg1 = (int)(SWIG_As_int(obj0));
8648 if (SWIG_arg_fail(1)) SWIG_fail;
8649 }
8650 }
8651 if (obj1) {
8652 {
8653 arg2 = (int)(SWIG_As_int(obj1));
8654 if (SWIG_arg_fail(2)) SWIG_fail;
8655 }
8656 }
8657 {
8658 PyThreadState* __tstate = wxPyBeginAllowThreads();
8659 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8660
8661 wxPyEndAllowThreads(__tstate);
8662 if (PyErr_Occurred()) SWIG_fail;
8663 }
8664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8665 return resultobj;
8666 fail:
8667 return NULL;
8668 }
8669
8670
8671 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8672 PyObject *resultobj;
8673 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8674 int result;
8675 PyObject * obj0 = 0 ;
8676 char *kwnames[] = {
8677 (char *) "self", NULL
8678 };
8679
8680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8682 if (SWIG_arg_fail(1)) SWIG_fail;
8683 {
8684 PyThreadState* __tstate = wxPyBeginAllowThreads();
8685 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8686
8687 wxPyEndAllowThreads(__tstate);
8688 if (PyErr_Occurred()) SWIG_fail;
8689 }
8690 {
8691 resultobj = SWIG_From_int((int)(result));
8692 }
8693 return resultobj;
8694 fail:
8695 return NULL;
8696 }
8697
8698
8699 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8700 PyObject *obj;
8701 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8702 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8703 Py_INCREF(obj);
8704 return Py_BuildValue((char *)"");
8705 }
8706 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8707 PyObject *resultobj;
8708 wxTimer *arg1 = 0 ;
8709 wxTimerRunner *result;
8710 PyObject * obj0 = 0 ;
8711
8712 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8713 {
8714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8715 if (SWIG_arg_fail(1)) SWIG_fail;
8716 if (arg1 == NULL) {
8717 SWIG_null_ref("wxTimer");
8718 }
8719 if (SWIG_arg_fail(1)) SWIG_fail;
8720 }
8721 {
8722 if (!wxPyCheckForApp()) SWIG_fail;
8723 PyThreadState* __tstate = wxPyBeginAllowThreads();
8724 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8725
8726 wxPyEndAllowThreads(__tstate);
8727 if (PyErr_Occurred()) SWIG_fail;
8728 }
8729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8730 return resultobj;
8731 fail:
8732 return NULL;
8733 }
8734
8735
8736 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8737 PyObject *resultobj;
8738 wxTimer *arg1 = 0 ;
8739 int arg2 ;
8740 bool arg3 = (bool) false ;
8741 wxTimerRunner *result;
8742 PyObject * obj0 = 0 ;
8743 PyObject * obj1 = 0 ;
8744 PyObject * obj2 = 0 ;
8745
8746 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8747 {
8748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8749 if (SWIG_arg_fail(1)) SWIG_fail;
8750 if (arg1 == NULL) {
8751 SWIG_null_ref("wxTimer");
8752 }
8753 if (SWIG_arg_fail(1)) SWIG_fail;
8754 }
8755 {
8756 arg2 = (int)(SWIG_As_int(obj1));
8757 if (SWIG_arg_fail(2)) SWIG_fail;
8758 }
8759 if (obj2) {
8760 {
8761 arg3 = (bool)(SWIG_As_bool(obj2));
8762 if (SWIG_arg_fail(3)) SWIG_fail;
8763 }
8764 }
8765 {
8766 if (!wxPyCheckForApp()) SWIG_fail;
8767 PyThreadState* __tstate = wxPyBeginAllowThreads();
8768 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8769
8770 wxPyEndAllowThreads(__tstate);
8771 if (PyErr_Occurred()) SWIG_fail;
8772 }
8773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8774 return resultobj;
8775 fail:
8776 return NULL;
8777 }
8778
8779
8780 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8781 int argc;
8782 PyObject *argv[4];
8783 int ii;
8784
8785 argc = PyObject_Length(args);
8786 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8787 argv[ii] = PyTuple_GetItem(args,ii);
8788 }
8789 if (argc == 1) {
8790 int _v;
8791 {
8792 void *ptr = 0;
8793 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8794 _v = 0;
8795 PyErr_Clear();
8796 } else {
8797 _v = (ptr != 0);
8798 }
8799 }
8800 if (_v) {
8801 return _wrap_new_TimerRunner__SWIG_0(self,args);
8802 }
8803 }
8804 if ((argc >= 2) && (argc <= 3)) {
8805 int _v;
8806 {
8807 void *ptr = 0;
8808 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8809 _v = 0;
8810 PyErr_Clear();
8811 } else {
8812 _v = (ptr != 0);
8813 }
8814 }
8815 if (_v) {
8816 _v = SWIG_Check_int(argv[1]);
8817 if (_v) {
8818 if (argc <= 2) {
8819 return _wrap_new_TimerRunner__SWIG_1(self,args);
8820 }
8821 _v = SWIG_Check_bool(argv[2]);
8822 if (_v) {
8823 return _wrap_new_TimerRunner__SWIG_1(self,args);
8824 }
8825 }
8826 }
8827 }
8828
8829 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8830 return NULL;
8831 }
8832
8833
8834 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8835 PyObject *resultobj;
8836 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8837 PyObject * obj0 = 0 ;
8838 char *kwnames[] = {
8839 (char *) "self", NULL
8840 };
8841
8842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8844 if (SWIG_arg_fail(1)) SWIG_fail;
8845 {
8846 PyThreadState* __tstate = wxPyBeginAllowThreads();
8847 delete arg1;
8848
8849 wxPyEndAllowThreads(__tstate);
8850 if (PyErr_Occurred()) SWIG_fail;
8851 }
8852 Py_INCREF(Py_None); resultobj = Py_None;
8853 return resultobj;
8854 fail:
8855 return NULL;
8856 }
8857
8858
8859 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8860 PyObject *resultobj;
8861 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8862 int arg2 ;
8863 bool arg3 = (bool) false ;
8864 PyObject * obj0 = 0 ;
8865 PyObject * obj1 = 0 ;
8866 PyObject * obj2 = 0 ;
8867 char *kwnames[] = {
8868 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8869 };
8870
8871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8873 if (SWIG_arg_fail(1)) SWIG_fail;
8874 {
8875 arg2 = (int)(SWIG_As_int(obj1));
8876 if (SWIG_arg_fail(2)) SWIG_fail;
8877 }
8878 if (obj2) {
8879 {
8880 arg3 = (bool)(SWIG_As_bool(obj2));
8881 if (SWIG_arg_fail(3)) SWIG_fail;
8882 }
8883 }
8884 {
8885 PyThreadState* __tstate = wxPyBeginAllowThreads();
8886 (arg1)->Start(arg2,arg3);
8887
8888 wxPyEndAllowThreads(__tstate);
8889 if (PyErr_Occurred()) SWIG_fail;
8890 }
8891 Py_INCREF(Py_None); resultobj = Py_None;
8892 return resultobj;
8893 fail:
8894 return NULL;
8895 }
8896
8897
8898 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8899 PyObject *obj;
8900 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8901 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8902 Py_INCREF(obj);
8903 return Py_BuildValue((char *)"");
8904 }
8905 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8906 PyObject *resultobj;
8907 wxLog *result;
8908 char *kwnames[] = {
8909 NULL
8910 };
8911
8912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8913 {
8914 PyThreadState* __tstate = wxPyBeginAllowThreads();
8915 result = (wxLog *)new wxLog();
8916
8917 wxPyEndAllowThreads(__tstate);
8918 if (PyErr_Occurred()) SWIG_fail;
8919 }
8920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8921 return resultobj;
8922 fail:
8923 return NULL;
8924 }
8925
8926
8927 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8928 PyObject *resultobj;
8929 bool result;
8930 char *kwnames[] = {
8931 NULL
8932 };
8933
8934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8935 {
8936 PyThreadState* __tstate = wxPyBeginAllowThreads();
8937 result = (bool)wxLog::IsEnabled();
8938
8939 wxPyEndAllowThreads(__tstate);
8940 if (PyErr_Occurred()) SWIG_fail;
8941 }
8942 {
8943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8944 }
8945 return resultobj;
8946 fail:
8947 return NULL;
8948 }
8949
8950
8951 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8952 PyObject *resultobj;
8953 bool arg1 = (bool) true ;
8954 bool result;
8955 PyObject * obj0 = 0 ;
8956 char *kwnames[] = {
8957 (char *) "doIt", NULL
8958 };
8959
8960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8961 if (obj0) {
8962 {
8963 arg1 = (bool)(SWIG_As_bool(obj0));
8964 if (SWIG_arg_fail(1)) SWIG_fail;
8965 }
8966 }
8967 {
8968 PyThreadState* __tstate = wxPyBeginAllowThreads();
8969 result = (bool)wxLog::EnableLogging(arg1);
8970
8971 wxPyEndAllowThreads(__tstate);
8972 if (PyErr_Occurred()) SWIG_fail;
8973 }
8974 {
8975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8976 }
8977 return resultobj;
8978 fail:
8979 return NULL;
8980 }
8981
8982
8983 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8984 PyObject *resultobj;
8985 wxLogLevel arg1 ;
8986 wxChar *arg2 = (wxChar *) 0 ;
8987 time_t arg3 ;
8988 PyObject * obj0 = 0 ;
8989 PyObject * obj1 = 0 ;
8990 PyObject * obj2 = 0 ;
8991 char *kwnames[] = {
8992 (char *) "level",(char *) "szString",(char *) "t", NULL
8993 };
8994
8995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8996 {
8997 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8998 if (SWIG_arg_fail(1)) SWIG_fail;
8999 }
9000 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9001 if (SWIG_arg_fail(2)) SWIG_fail;
9002 {
9003 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
9004 if (SWIG_arg_fail(3)) SWIG_fail;
9005 }
9006 {
9007 PyThreadState* __tstate = wxPyBeginAllowThreads();
9008 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
9009
9010 wxPyEndAllowThreads(__tstate);
9011 if (PyErr_Occurred()) SWIG_fail;
9012 }
9013 Py_INCREF(Py_None); resultobj = Py_None;
9014 return resultobj;
9015 fail:
9016 return NULL;
9017 }
9018
9019
9020 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
9021 PyObject *resultobj;
9022 wxLog *arg1 = (wxLog *) 0 ;
9023 PyObject * obj0 = 0 ;
9024 char *kwnames[] = {
9025 (char *) "self", NULL
9026 };
9027
9028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
9029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9030 if (SWIG_arg_fail(1)) SWIG_fail;
9031 {
9032 PyThreadState* __tstate = wxPyBeginAllowThreads();
9033 (arg1)->Flush();
9034
9035 wxPyEndAllowThreads(__tstate);
9036 if (PyErr_Occurred()) SWIG_fail;
9037 }
9038 Py_INCREF(Py_None); resultobj = Py_None;
9039 return resultobj;
9040 fail:
9041 return NULL;
9042 }
9043
9044
9045 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj;
9047 char *kwnames[] = {
9048 NULL
9049 };
9050
9051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9052 {
9053 PyThreadState* __tstate = wxPyBeginAllowThreads();
9054 wxLog::FlushActive();
9055
9056 wxPyEndAllowThreads(__tstate);
9057 if (PyErr_Occurred()) SWIG_fail;
9058 }
9059 Py_INCREF(Py_None); resultobj = Py_None;
9060 return resultobj;
9061 fail:
9062 return NULL;
9063 }
9064
9065
9066 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9067 PyObject *resultobj;
9068 wxLog *result;
9069 char *kwnames[] = {
9070 NULL
9071 };
9072
9073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9074 {
9075 PyThreadState* __tstate = wxPyBeginAllowThreads();
9076 result = (wxLog *)wxLog::GetActiveTarget();
9077
9078 wxPyEndAllowThreads(__tstate);
9079 if (PyErr_Occurred()) SWIG_fail;
9080 }
9081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9082 return resultobj;
9083 fail:
9084 return NULL;
9085 }
9086
9087
9088 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9089 PyObject *resultobj;
9090 wxLog *arg1 = (wxLog *) 0 ;
9091 wxLog *result;
9092 PyObject * obj0 = 0 ;
9093 char *kwnames[] = {
9094 (char *) "pLogger", NULL
9095 };
9096
9097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9099 if (SWIG_arg_fail(1)) SWIG_fail;
9100 {
9101 PyThreadState* __tstate = wxPyBeginAllowThreads();
9102 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9103
9104 wxPyEndAllowThreads(__tstate);
9105 if (PyErr_Occurred()) SWIG_fail;
9106 }
9107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9108 return resultobj;
9109 fail:
9110 return NULL;
9111 }
9112
9113
9114 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9115 PyObject *resultobj;
9116 char *kwnames[] = {
9117 NULL
9118 };
9119
9120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9121 {
9122 PyThreadState* __tstate = wxPyBeginAllowThreads();
9123 wxLog::Suspend();
9124
9125 wxPyEndAllowThreads(__tstate);
9126 if (PyErr_Occurred()) SWIG_fail;
9127 }
9128 Py_INCREF(Py_None); resultobj = Py_None;
9129 return resultobj;
9130 fail:
9131 return NULL;
9132 }
9133
9134
9135 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9136 PyObject *resultobj;
9137 char *kwnames[] = {
9138 NULL
9139 };
9140
9141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9142 {
9143 PyThreadState* __tstate = wxPyBeginAllowThreads();
9144 wxLog::Resume();
9145
9146 wxPyEndAllowThreads(__tstate);
9147 if (PyErr_Occurred()) SWIG_fail;
9148 }
9149 Py_INCREF(Py_None); resultobj = Py_None;
9150 return resultobj;
9151 fail:
9152 return NULL;
9153 }
9154
9155
9156 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9157 PyObject *resultobj;
9158 bool arg1 = (bool) true ;
9159 PyObject * obj0 = 0 ;
9160 char *kwnames[] = {
9161 (char *) "bVerbose", NULL
9162 };
9163
9164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9165 if (obj0) {
9166 {
9167 arg1 = (bool)(SWIG_As_bool(obj0));
9168 if (SWIG_arg_fail(1)) SWIG_fail;
9169 }
9170 }
9171 {
9172 PyThreadState* __tstate = wxPyBeginAllowThreads();
9173 wxLog::SetVerbose(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_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9186 PyObject *resultobj;
9187 wxLogLevel arg1 ;
9188 PyObject * obj0 = 0 ;
9189 char *kwnames[] = {
9190 (char *) "logLevel", NULL
9191 };
9192
9193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9194 {
9195 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9196 if (SWIG_arg_fail(1)) SWIG_fail;
9197 }
9198 {
9199 PyThreadState* __tstate = wxPyBeginAllowThreads();
9200 wxLog::SetLogLevel(arg1);
9201
9202 wxPyEndAllowThreads(__tstate);
9203 if (PyErr_Occurred()) SWIG_fail;
9204 }
9205 Py_INCREF(Py_None); resultobj = Py_None;
9206 return resultobj;
9207 fail:
9208 return NULL;
9209 }
9210
9211
9212 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9213 PyObject *resultobj;
9214 char *kwnames[] = {
9215 NULL
9216 };
9217
9218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9219 {
9220 PyThreadState* __tstate = wxPyBeginAllowThreads();
9221 wxLog::DontCreateOnDemand();
9222
9223 wxPyEndAllowThreads(__tstate);
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 Py_INCREF(Py_None); resultobj = Py_None;
9227 return resultobj;
9228 fail:
9229 return NULL;
9230 }
9231
9232
9233 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9234 PyObject *resultobj;
9235 wxTraceMask arg1 ;
9236 PyObject * obj0 = 0 ;
9237 char *kwnames[] = {
9238 (char *) "ulMask", NULL
9239 };
9240
9241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9242 {
9243 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9244 if (SWIG_arg_fail(1)) SWIG_fail;
9245 }
9246 {
9247 PyThreadState* __tstate = wxPyBeginAllowThreads();
9248 wxLog::SetTraceMask(arg1);
9249
9250 wxPyEndAllowThreads(__tstate);
9251 if (PyErr_Occurred()) SWIG_fail;
9252 }
9253 Py_INCREF(Py_None); resultobj = Py_None;
9254 return resultobj;
9255 fail:
9256 return NULL;
9257 }
9258
9259
9260 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9261 PyObject *resultobj;
9262 wxString *arg1 = 0 ;
9263 bool temp1 = false ;
9264 PyObject * obj0 = 0 ;
9265 char *kwnames[] = {
9266 (char *) "str", NULL
9267 };
9268
9269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9270 {
9271 arg1 = wxString_in_helper(obj0);
9272 if (arg1 == NULL) SWIG_fail;
9273 temp1 = true;
9274 }
9275 {
9276 PyThreadState* __tstate = wxPyBeginAllowThreads();
9277 wxLog::AddTraceMask((wxString const &)*arg1);
9278
9279 wxPyEndAllowThreads(__tstate);
9280 if (PyErr_Occurred()) SWIG_fail;
9281 }
9282 Py_INCREF(Py_None); resultobj = Py_None;
9283 {
9284 if (temp1)
9285 delete arg1;
9286 }
9287 return resultobj;
9288 fail:
9289 {
9290 if (temp1)
9291 delete arg1;
9292 }
9293 return NULL;
9294 }
9295
9296
9297 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9298 PyObject *resultobj;
9299 wxString *arg1 = 0 ;
9300 bool temp1 = false ;
9301 PyObject * obj0 = 0 ;
9302 char *kwnames[] = {
9303 (char *) "str", NULL
9304 };
9305
9306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9307 {
9308 arg1 = wxString_in_helper(obj0);
9309 if (arg1 == NULL) SWIG_fail;
9310 temp1 = true;
9311 }
9312 {
9313 PyThreadState* __tstate = wxPyBeginAllowThreads();
9314 wxLog::RemoveTraceMask((wxString const &)*arg1);
9315
9316 wxPyEndAllowThreads(__tstate);
9317 if (PyErr_Occurred()) SWIG_fail;
9318 }
9319 Py_INCREF(Py_None); resultobj = Py_None;
9320 {
9321 if (temp1)
9322 delete arg1;
9323 }
9324 return resultobj;
9325 fail:
9326 {
9327 if (temp1)
9328 delete arg1;
9329 }
9330 return NULL;
9331 }
9332
9333
9334 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9335 PyObject *resultobj;
9336 char *kwnames[] = {
9337 NULL
9338 };
9339
9340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9341 {
9342 PyThreadState* __tstate = wxPyBeginAllowThreads();
9343 wxLog::ClearTraceMasks();
9344
9345 wxPyEndAllowThreads(__tstate);
9346 if (PyErr_Occurred()) SWIG_fail;
9347 }
9348 Py_INCREF(Py_None); resultobj = Py_None;
9349 return resultobj;
9350 fail:
9351 return NULL;
9352 }
9353
9354
9355 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9356 PyObject *resultobj;
9357 wxArrayString *result;
9358 char *kwnames[] = {
9359 NULL
9360 };
9361
9362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9363 {
9364 PyThreadState* __tstate = wxPyBeginAllowThreads();
9365 {
9366 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9367 result = (wxArrayString *) &_result_ref;
9368 }
9369
9370 wxPyEndAllowThreads(__tstate);
9371 if (PyErr_Occurred()) SWIG_fail;
9372 }
9373 {
9374 resultobj = wxArrayString2PyList_helper(*result);
9375 }
9376 return resultobj;
9377 fail:
9378 return NULL;
9379 }
9380
9381
9382 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9383 PyObject *resultobj;
9384 wxChar *arg1 = (wxChar *) 0 ;
9385 PyObject * obj0 = 0 ;
9386 char *kwnames[] = {
9387 (char *) "ts", NULL
9388 };
9389
9390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9392 if (SWIG_arg_fail(1)) SWIG_fail;
9393 {
9394 PyThreadState* __tstate = wxPyBeginAllowThreads();
9395 wxLog::SetTimestamp((wxChar const *)arg1);
9396
9397 wxPyEndAllowThreads(__tstate);
9398 if (PyErr_Occurred()) SWIG_fail;
9399 }
9400 Py_INCREF(Py_None); resultobj = Py_None;
9401 return resultobj;
9402 fail:
9403 return NULL;
9404 }
9405
9406
9407 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9408 PyObject *resultobj;
9409 bool result;
9410 char *kwnames[] = {
9411 NULL
9412 };
9413
9414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9415 {
9416 PyThreadState* __tstate = wxPyBeginAllowThreads();
9417 result = (bool)wxLog::GetVerbose();
9418
9419 wxPyEndAllowThreads(__tstate);
9420 if (PyErr_Occurred()) SWIG_fail;
9421 }
9422 {
9423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9424 }
9425 return resultobj;
9426 fail:
9427 return NULL;
9428 }
9429
9430
9431 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9432 PyObject *resultobj;
9433 wxTraceMask result;
9434 char *kwnames[] = {
9435 NULL
9436 };
9437
9438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9439 {
9440 PyThreadState* __tstate = wxPyBeginAllowThreads();
9441 result = (wxTraceMask)wxLog::GetTraceMask();
9442
9443 wxPyEndAllowThreads(__tstate);
9444 if (PyErr_Occurred()) SWIG_fail;
9445 }
9446 {
9447 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9448 }
9449 return resultobj;
9450 fail:
9451 return NULL;
9452 }
9453
9454
9455 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9456 PyObject *resultobj;
9457 wxChar *arg1 = (wxChar *) 0 ;
9458 bool result;
9459 PyObject * obj0 = 0 ;
9460 char *kwnames[] = {
9461 (char *) "mask", NULL
9462 };
9463
9464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9466 if (SWIG_arg_fail(1)) SWIG_fail;
9467 {
9468 PyThreadState* __tstate = wxPyBeginAllowThreads();
9469 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9470
9471 wxPyEndAllowThreads(__tstate);
9472 if (PyErr_Occurred()) SWIG_fail;
9473 }
9474 {
9475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9476 }
9477 return resultobj;
9478 fail:
9479 return NULL;
9480 }
9481
9482
9483 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9484 PyObject *resultobj;
9485 wxLogLevel result;
9486 char *kwnames[] = {
9487 NULL
9488 };
9489
9490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9491 {
9492 PyThreadState* __tstate = wxPyBeginAllowThreads();
9493 result = (wxLogLevel)wxLog::GetLogLevel();
9494
9495 wxPyEndAllowThreads(__tstate);
9496 if (PyErr_Occurred()) SWIG_fail;
9497 }
9498 {
9499 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9500 }
9501 return resultobj;
9502 fail:
9503 return NULL;
9504 }
9505
9506
9507 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9508 PyObject *resultobj;
9509 wxChar *result;
9510 char *kwnames[] = {
9511 NULL
9512 };
9513
9514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9515 {
9516 PyThreadState* __tstate = wxPyBeginAllowThreads();
9517 result = (wxChar *)wxLog::GetTimestamp();
9518
9519 wxPyEndAllowThreads(__tstate);
9520 if (PyErr_Occurred()) SWIG_fail;
9521 }
9522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9523 return resultobj;
9524 fail:
9525 return NULL;
9526 }
9527
9528
9529 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9530 PyObject *resultobj;
9531 wxString result;
9532 char *kwnames[] = {
9533 NULL
9534 };
9535
9536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9537 {
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 result = Log_TimeStamp();
9540
9541 wxPyEndAllowThreads(__tstate);
9542 if (PyErr_Occurred()) SWIG_fail;
9543 }
9544 {
9545 #if wxUSE_UNICODE
9546 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9547 #else
9548 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9549 #endif
9550 }
9551 return resultobj;
9552 fail:
9553 return NULL;
9554 }
9555
9556
9557 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9558 PyObject *resultobj;
9559 wxLog *arg1 = (wxLog *) 0 ;
9560 PyObject * obj0 = 0 ;
9561 char *kwnames[] = {
9562 (char *) "self", NULL
9563 };
9564
9565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9567 if (SWIG_arg_fail(1)) SWIG_fail;
9568 {
9569 PyThreadState* __tstate = wxPyBeginAllowThreads();
9570 wxLog_Destroy(arg1);
9571
9572 wxPyEndAllowThreads(__tstate);
9573 if (PyErr_Occurred()) SWIG_fail;
9574 }
9575 Py_INCREF(Py_None); resultobj = Py_None;
9576 return resultobj;
9577 fail:
9578 return NULL;
9579 }
9580
9581
9582 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9583 PyObject *obj;
9584 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9585 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9586 Py_INCREF(obj);
9587 return Py_BuildValue((char *)"");
9588 }
9589 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9590 PyObject *resultobj;
9591 wxLogStderr *result;
9592 char *kwnames[] = {
9593 NULL
9594 };
9595
9596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9597 {
9598 PyThreadState* __tstate = wxPyBeginAllowThreads();
9599 result = (wxLogStderr *)new wxLogStderr();
9600
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9605 return resultobj;
9606 fail:
9607 return NULL;
9608 }
9609
9610
9611 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9612 PyObject *obj;
9613 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9614 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9615 Py_INCREF(obj);
9616 return Py_BuildValue((char *)"");
9617 }
9618 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9619 PyObject *resultobj;
9620 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9621 wxLogTextCtrl *result;
9622 PyObject * obj0 = 0 ;
9623 char *kwnames[] = {
9624 (char *) "pTextCtrl", NULL
9625 };
9626
9627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9629 if (SWIG_arg_fail(1)) SWIG_fail;
9630 {
9631 PyThreadState* __tstate = wxPyBeginAllowThreads();
9632 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9633
9634 wxPyEndAllowThreads(__tstate);
9635 if (PyErr_Occurred()) SWIG_fail;
9636 }
9637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9638 return resultobj;
9639 fail:
9640 return NULL;
9641 }
9642
9643
9644 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9645 PyObject *obj;
9646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9647 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9648 Py_INCREF(obj);
9649 return Py_BuildValue((char *)"");
9650 }
9651 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9652 PyObject *resultobj;
9653 wxLogGui *result;
9654 char *kwnames[] = {
9655 NULL
9656 };
9657
9658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9659 {
9660 PyThreadState* __tstate = wxPyBeginAllowThreads();
9661 result = (wxLogGui *)new wxLogGui();
9662
9663 wxPyEndAllowThreads(__tstate);
9664 if (PyErr_Occurred()) SWIG_fail;
9665 }
9666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9667 return resultobj;
9668 fail:
9669 return NULL;
9670 }
9671
9672
9673 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9674 PyObject *obj;
9675 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9676 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9677 Py_INCREF(obj);
9678 return Py_BuildValue((char *)"");
9679 }
9680 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9681 PyObject *resultobj;
9682 wxFrame *arg1 = (wxFrame *) 0 ;
9683 wxString *arg2 = 0 ;
9684 bool arg3 = (bool) true ;
9685 bool arg4 = (bool) true ;
9686 wxLogWindow *result;
9687 bool temp2 = false ;
9688 PyObject * obj0 = 0 ;
9689 PyObject * obj1 = 0 ;
9690 PyObject * obj2 = 0 ;
9691 PyObject * obj3 = 0 ;
9692 char *kwnames[] = {
9693 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9694 };
9695
9696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9698 if (SWIG_arg_fail(1)) SWIG_fail;
9699 {
9700 arg2 = wxString_in_helper(obj1);
9701 if (arg2 == NULL) SWIG_fail;
9702 temp2 = true;
9703 }
9704 if (obj2) {
9705 {
9706 arg3 = (bool)(SWIG_As_bool(obj2));
9707 if (SWIG_arg_fail(3)) SWIG_fail;
9708 }
9709 }
9710 if (obj3) {
9711 {
9712 arg4 = (bool)(SWIG_As_bool(obj3));
9713 if (SWIG_arg_fail(4)) SWIG_fail;
9714 }
9715 }
9716 {
9717 PyThreadState* __tstate = wxPyBeginAllowThreads();
9718 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9719
9720 wxPyEndAllowThreads(__tstate);
9721 if (PyErr_Occurred()) SWIG_fail;
9722 }
9723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9724 {
9725 if (temp2)
9726 delete arg2;
9727 }
9728 return resultobj;
9729 fail:
9730 {
9731 if (temp2)
9732 delete arg2;
9733 }
9734 return NULL;
9735 }
9736
9737
9738 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9739 PyObject *resultobj;
9740 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9741 bool arg2 = (bool) true ;
9742 PyObject * obj0 = 0 ;
9743 PyObject * obj1 = 0 ;
9744 char *kwnames[] = {
9745 (char *) "self",(char *) "bShow", NULL
9746 };
9747
9748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9750 if (SWIG_arg_fail(1)) SWIG_fail;
9751 if (obj1) {
9752 {
9753 arg2 = (bool)(SWIG_As_bool(obj1));
9754 if (SWIG_arg_fail(2)) SWIG_fail;
9755 }
9756 }
9757 {
9758 PyThreadState* __tstate = wxPyBeginAllowThreads();
9759 (arg1)->Show(arg2);
9760
9761 wxPyEndAllowThreads(__tstate);
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 Py_INCREF(Py_None); resultobj = Py_None;
9765 return resultobj;
9766 fail:
9767 return NULL;
9768 }
9769
9770
9771 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9772 PyObject *resultobj;
9773 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9774 wxFrame *result;
9775 PyObject * obj0 = 0 ;
9776 char *kwnames[] = {
9777 (char *) "self", NULL
9778 };
9779
9780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9782 if (SWIG_arg_fail(1)) SWIG_fail;
9783 {
9784 PyThreadState* __tstate = wxPyBeginAllowThreads();
9785 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9786
9787 wxPyEndAllowThreads(__tstate);
9788 if (PyErr_Occurred()) SWIG_fail;
9789 }
9790 {
9791 resultobj = wxPyMake_wxObject(result, 0);
9792 }
9793 return resultobj;
9794 fail:
9795 return NULL;
9796 }
9797
9798
9799 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9800 PyObject *resultobj;
9801 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9802 wxLog *result;
9803 PyObject * obj0 = 0 ;
9804 char *kwnames[] = {
9805 (char *) "self", NULL
9806 };
9807
9808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9810 if (SWIG_arg_fail(1)) SWIG_fail;
9811 {
9812 PyThreadState* __tstate = wxPyBeginAllowThreads();
9813 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9814
9815 wxPyEndAllowThreads(__tstate);
9816 if (PyErr_Occurred()) SWIG_fail;
9817 }
9818 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9819 return resultobj;
9820 fail:
9821 return NULL;
9822 }
9823
9824
9825 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9826 PyObject *resultobj;
9827 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9828 bool result;
9829 PyObject * obj0 = 0 ;
9830 char *kwnames[] = {
9831 (char *) "self", NULL
9832 };
9833
9834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9836 if (SWIG_arg_fail(1)) SWIG_fail;
9837 {
9838 PyThreadState* __tstate = wxPyBeginAllowThreads();
9839 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9840
9841 wxPyEndAllowThreads(__tstate);
9842 if (PyErr_Occurred()) SWIG_fail;
9843 }
9844 {
9845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9846 }
9847 return resultobj;
9848 fail:
9849 return NULL;
9850 }
9851
9852
9853 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9854 PyObject *resultobj;
9855 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9856 bool arg2 ;
9857 PyObject * obj0 = 0 ;
9858 PyObject * obj1 = 0 ;
9859 char *kwnames[] = {
9860 (char *) "self",(char *) "bDoPass", NULL
9861 };
9862
9863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9865 if (SWIG_arg_fail(1)) SWIG_fail;
9866 {
9867 arg2 = (bool)(SWIG_As_bool(obj1));
9868 if (SWIG_arg_fail(2)) SWIG_fail;
9869 }
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 (arg1)->PassMessages(arg2);
9873
9874 wxPyEndAllowThreads(__tstate);
9875 if (PyErr_Occurred()) SWIG_fail;
9876 }
9877 Py_INCREF(Py_None); resultobj = Py_None;
9878 return resultobj;
9879 fail:
9880 return NULL;
9881 }
9882
9883
9884 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9885 PyObject *obj;
9886 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9887 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9888 Py_INCREF(obj);
9889 return Py_BuildValue((char *)"");
9890 }
9891 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9892 PyObject *resultobj;
9893 wxLog *arg1 = (wxLog *) 0 ;
9894 wxLogChain *result;
9895 PyObject * obj0 = 0 ;
9896 char *kwnames[] = {
9897 (char *) "logger", NULL
9898 };
9899
9900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9902 if (SWIG_arg_fail(1)) SWIG_fail;
9903 {
9904 PyThreadState* __tstate = wxPyBeginAllowThreads();
9905 result = (wxLogChain *)new wxLogChain(arg1);
9906
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9918 PyObject *resultobj;
9919 wxLogChain *arg1 = (wxLogChain *) 0 ;
9920 wxLog *arg2 = (wxLog *) 0 ;
9921 PyObject * obj0 = 0 ;
9922 PyObject * obj1 = 0 ;
9923 char *kwnames[] = {
9924 (char *) "self",(char *) "logger", NULL
9925 };
9926
9927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9929 if (SWIG_arg_fail(1)) SWIG_fail;
9930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9931 if (SWIG_arg_fail(2)) SWIG_fail;
9932 {
9933 PyThreadState* __tstate = wxPyBeginAllowThreads();
9934 (arg1)->SetLog(arg2);
9935
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 Py_INCREF(Py_None); resultobj = Py_None;
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9947 PyObject *resultobj;
9948 wxLogChain *arg1 = (wxLogChain *) 0 ;
9949 bool arg2 ;
9950 PyObject * obj0 = 0 ;
9951 PyObject * obj1 = 0 ;
9952 char *kwnames[] = {
9953 (char *) "self",(char *) "bDoPass", NULL
9954 };
9955
9956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9958 if (SWIG_arg_fail(1)) SWIG_fail;
9959 {
9960 arg2 = (bool)(SWIG_As_bool(obj1));
9961 if (SWIG_arg_fail(2)) SWIG_fail;
9962 }
9963 {
9964 PyThreadState* __tstate = wxPyBeginAllowThreads();
9965 (arg1)->PassMessages(arg2);
9966
9967 wxPyEndAllowThreads(__tstate);
9968 if (PyErr_Occurred()) SWIG_fail;
9969 }
9970 Py_INCREF(Py_None); resultobj = Py_None;
9971 return resultobj;
9972 fail:
9973 return NULL;
9974 }
9975
9976
9977 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9978 PyObject *resultobj;
9979 wxLogChain *arg1 = (wxLogChain *) 0 ;
9980 bool result;
9981 PyObject * obj0 = 0 ;
9982 char *kwnames[] = {
9983 (char *) "self", NULL
9984 };
9985
9986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9988 if (SWIG_arg_fail(1)) SWIG_fail;
9989 {
9990 PyThreadState* __tstate = wxPyBeginAllowThreads();
9991 result = (bool)(arg1)->IsPassingMessages();
9992
9993 wxPyEndAllowThreads(__tstate);
9994 if (PyErr_Occurred()) SWIG_fail;
9995 }
9996 {
9997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9998 }
9999 return resultobj;
10000 fail:
10001 return NULL;
10002 }
10003
10004
10005 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10006 PyObject *resultobj;
10007 wxLogChain *arg1 = (wxLogChain *) 0 ;
10008 wxLog *result;
10009 PyObject * obj0 = 0 ;
10010 char *kwnames[] = {
10011 (char *) "self", NULL
10012 };
10013
10014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
10015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10016 if (SWIG_arg_fail(1)) SWIG_fail;
10017 {
10018 PyThreadState* __tstate = wxPyBeginAllowThreads();
10019 result = (wxLog *)(arg1)->GetOldLog();
10020
10021 wxPyEndAllowThreads(__tstate);
10022 if (PyErr_Occurred()) SWIG_fail;
10023 }
10024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10025 return resultobj;
10026 fail:
10027 return NULL;
10028 }
10029
10030
10031 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
10032 PyObject *obj;
10033 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10034 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10035 Py_INCREF(obj);
10036 return Py_BuildValue((char *)"");
10037 }
10038 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10039 PyObject *resultobj;
10040 unsigned long result;
10041 char *kwnames[] = {
10042 NULL
10043 };
10044
10045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10046 {
10047 PyThreadState* __tstate = wxPyBeginAllowThreads();
10048 result = (unsigned long)wxSysErrorCode();
10049
10050 wxPyEndAllowThreads(__tstate);
10051 if (PyErr_Occurred()) SWIG_fail;
10052 }
10053 {
10054 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10055 }
10056 return resultobj;
10057 fail:
10058 return NULL;
10059 }
10060
10061
10062 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10063 PyObject *resultobj;
10064 unsigned long arg1 = (unsigned long) 0 ;
10065 wxString result;
10066 PyObject * obj0 = 0 ;
10067 char *kwnames[] = {
10068 (char *) "nErrCode", NULL
10069 };
10070
10071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10072 if (obj0) {
10073 {
10074 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10075 if (SWIG_arg_fail(1)) SWIG_fail;
10076 }
10077 }
10078 {
10079 PyThreadState* __tstate = wxPyBeginAllowThreads();
10080 result = wxSysErrorMsg(arg1);
10081
10082 wxPyEndAllowThreads(__tstate);
10083 if (PyErr_Occurred()) SWIG_fail;
10084 }
10085 {
10086 #if wxUSE_UNICODE
10087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10088 #else
10089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10090 #endif
10091 }
10092 return resultobj;
10093 fail:
10094 return NULL;
10095 }
10096
10097
10098 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10099 PyObject *resultobj;
10100 wxString *arg1 = 0 ;
10101 bool temp1 = false ;
10102 PyObject * obj0 = 0 ;
10103 char *kwnames[] = {
10104 (char *) "msg", NULL
10105 };
10106
10107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10108 {
10109 arg1 = wxString_in_helper(obj0);
10110 if (arg1 == NULL) SWIG_fail;
10111 temp1 = true;
10112 }
10113 {
10114 PyThreadState* __tstate = wxPyBeginAllowThreads();
10115 wxPyLogFatalError((wxString const &)*arg1);
10116
10117 wxPyEndAllowThreads(__tstate);
10118 if (PyErr_Occurred()) SWIG_fail;
10119 }
10120 Py_INCREF(Py_None); resultobj = Py_None;
10121 {
10122 if (temp1)
10123 delete arg1;
10124 }
10125 return resultobj;
10126 fail:
10127 {
10128 if (temp1)
10129 delete arg1;
10130 }
10131 return NULL;
10132 }
10133
10134
10135 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10136 PyObject *resultobj;
10137 wxString *arg1 = 0 ;
10138 bool temp1 = false ;
10139 PyObject * obj0 = 0 ;
10140 char *kwnames[] = {
10141 (char *) "msg", NULL
10142 };
10143
10144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10145 {
10146 arg1 = wxString_in_helper(obj0);
10147 if (arg1 == NULL) SWIG_fail;
10148 temp1 = true;
10149 }
10150 {
10151 PyThreadState* __tstate = wxPyBeginAllowThreads();
10152 wxPyLogError((wxString const &)*arg1);
10153
10154 wxPyEndAllowThreads(__tstate);
10155 if (PyErr_Occurred()) SWIG_fail;
10156 }
10157 Py_INCREF(Py_None); resultobj = Py_None;
10158 {
10159 if (temp1)
10160 delete arg1;
10161 }
10162 return resultobj;
10163 fail:
10164 {
10165 if (temp1)
10166 delete arg1;
10167 }
10168 return NULL;
10169 }
10170
10171
10172 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10173 PyObject *resultobj;
10174 wxString *arg1 = 0 ;
10175 bool temp1 = false ;
10176 PyObject * obj0 = 0 ;
10177 char *kwnames[] = {
10178 (char *) "msg", NULL
10179 };
10180
10181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10182 {
10183 arg1 = wxString_in_helper(obj0);
10184 if (arg1 == NULL) SWIG_fail;
10185 temp1 = true;
10186 }
10187 {
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 wxPyLogWarning((wxString const &)*arg1);
10190
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 Py_INCREF(Py_None); resultobj = Py_None;
10195 {
10196 if (temp1)
10197 delete arg1;
10198 }
10199 return resultobj;
10200 fail:
10201 {
10202 if (temp1)
10203 delete arg1;
10204 }
10205 return NULL;
10206 }
10207
10208
10209 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10210 PyObject *resultobj;
10211 wxString *arg1 = 0 ;
10212 bool temp1 = false ;
10213 PyObject * obj0 = 0 ;
10214 char *kwnames[] = {
10215 (char *) "msg", NULL
10216 };
10217
10218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10219 {
10220 arg1 = wxString_in_helper(obj0);
10221 if (arg1 == NULL) SWIG_fail;
10222 temp1 = true;
10223 }
10224 {
10225 PyThreadState* __tstate = wxPyBeginAllowThreads();
10226 wxPyLogMessage((wxString const &)*arg1);
10227
10228 wxPyEndAllowThreads(__tstate);
10229 if (PyErr_Occurred()) SWIG_fail;
10230 }
10231 Py_INCREF(Py_None); resultobj = Py_None;
10232 {
10233 if (temp1)
10234 delete arg1;
10235 }
10236 return resultobj;
10237 fail:
10238 {
10239 if (temp1)
10240 delete arg1;
10241 }
10242 return NULL;
10243 }
10244
10245
10246 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10247 PyObject *resultobj;
10248 wxString *arg1 = 0 ;
10249 bool temp1 = false ;
10250 PyObject * obj0 = 0 ;
10251 char *kwnames[] = {
10252 (char *) "msg", NULL
10253 };
10254
10255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10256 {
10257 arg1 = wxString_in_helper(obj0);
10258 if (arg1 == NULL) SWIG_fail;
10259 temp1 = true;
10260 }
10261 {
10262 PyThreadState* __tstate = wxPyBeginAllowThreads();
10263 wxPyLogInfo((wxString const &)*arg1);
10264
10265 wxPyEndAllowThreads(__tstate);
10266 if (PyErr_Occurred()) SWIG_fail;
10267 }
10268 Py_INCREF(Py_None); resultobj = Py_None;
10269 {
10270 if (temp1)
10271 delete arg1;
10272 }
10273 return resultobj;
10274 fail:
10275 {
10276 if (temp1)
10277 delete arg1;
10278 }
10279 return NULL;
10280 }
10281
10282
10283 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10284 PyObject *resultobj;
10285 wxString *arg1 = 0 ;
10286 bool temp1 = false ;
10287 PyObject * obj0 = 0 ;
10288 char *kwnames[] = {
10289 (char *) "msg", NULL
10290 };
10291
10292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10293 {
10294 arg1 = wxString_in_helper(obj0);
10295 if (arg1 == NULL) SWIG_fail;
10296 temp1 = true;
10297 }
10298 {
10299 PyThreadState* __tstate = wxPyBeginAllowThreads();
10300 wxPyLogDebug((wxString const &)*arg1);
10301
10302 wxPyEndAllowThreads(__tstate);
10303 if (PyErr_Occurred()) SWIG_fail;
10304 }
10305 Py_INCREF(Py_None); resultobj = Py_None;
10306 {
10307 if (temp1)
10308 delete arg1;
10309 }
10310 return resultobj;
10311 fail:
10312 {
10313 if (temp1)
10314 delete arg1;
10315 }
10316 return NULL;
10317 }
10318
10319
10320 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10321 PyObject *resultobj;
10322 wxString *arg1 = 0 ;
10323 bool temp1 = false ;
10324 PyObject * obj0 = 0 ;
10325 char *kwnames[] = {
10326 (char *) "msg", NULL
10327 };
10328
10329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10330 {
10331 arg1 = wxString_in_helper(obj0);
10332 if (arg1 == NULL) SWIG_fail;
10333 temp1 = true;
10334 }
10335 {
10336 PyThreadState* __tstate = wxPyBeginAllowThreads();
10337 wxPyLogVerbose((wxString const &)*arg1);
10338
10339 wxPyEndAllowThreads(__tstate);
10340 if (PyErr_Occurred()) SWIG_fail;
10341 }
10342 Py_INCREF(Py_None); resultobj = Py_None;
10343 {
10344 if (temp1)
10345 delete arg1;
10346 }
10347 return resultobj;
10348 fail:
10349 {
10350 if (temp1)
10351 delete arg1;
10352 }
10353 return NULL;
10354 }
10355
10356
10357 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10358 PyObject *resultobj;
10359 wxString *arg1 = 0 ;
10360 bool temp1 = false ;
10361 PyObject * obj0 = 0 ;
10362 char *kwnames[] = {
10363 (char *) "msg", NULL
10364 };
10365
10366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10367 {
10368 arg1 = wxString_in_helper(obj0);
10369 if (arg1 == NULL) SWIG_fail;
10370 temp1 = true;
10371 }
10372 {
10373 PyThreadState* __tstate = wxPyBeginAllowThreads();
10374 wxPyLogStatus((wxString const &)*arg1);
10375
10376 wxPyEndAllowThreads(__tstate);
10377 if (PyErr_Occurred()) SWIG_fail;
10378 }
10379 Py_INCREF(Py_None); resultobj = Py_None;
10380 {
10381 if (temp1)
10382 delete arg1;
10383 }
10384 return resultobj;
10385 fail:
10386 {
10387 if (temp1)
10388 delete arg1;
10389 }
10390 return NULL;
10391 }
10392
10393
10394 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10395 PyObject *resultobj;
10396 wxFrame *arg1 = (wxFrame *) 0 ;
10397 wxString *arg2 = 0 ;
10398 bool temp2 = false ;
10399 PyObject * obj0 = 0 ;
10400 PyObject * obj1 = 0 ;
10401 char *kwnames[] = {
10402 (char *) "pFrame",(char *) "msg", NULL
10403 };
10404
10405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10407 if (SWIG_arg_fail(1)) SWIG_fail;
10408 {
10409 arg2 = wxString_in_helper(obj1);
10410 if (arg2 == NULL) SWIG_fail;
10411 temp2 = true;
10412 }
10413 {
10414 PyThreadState* __tstate = wxPyBeginAllowThreads();
10415 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10416
10417 wxPyEndAllowThreads(__tstate);
10418 if (PyErr_Occurred()) SWIG_fail;
10419 }
10420 Py_INCREF(Py_None); resultobj = Py_None;
10421 {
10422 if (temp2)
10423 delete arg2;
10424 }
10425 return resultobj;
10426 fail:
10427 {
10428 if (temp2)
10429 delete arg2;
10430 }
10431 return NULL;
10432 }
10433
10434
10435 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10436 PyObject *resultobj;
10437 wxString *arg1 = 0 ;
10438 bool temp1 = false ;
10439 PyObject * obj0 = 0 ;
10440 char *kwnames[] = {
10441 (char *) "msg", NULL
10442 };
10443
10444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10445 {
10446 arg1 = wxString_in_helper(obj0);
10447 if (arg1 == NULL) SWIG_fail;
10448 temp1 = true;
10449 }
10450 {
10451 PyThreadState* __tstate = wxPyBeginAllowThreads();
10452 wxPyLogSysError((wxString const &)*arg1);
10453
10454 wxPyEndAllowThreads(__tstate);
10455 if (PyErr_Occurred()) SWIG_fail;
10456 }
10457 Py_INCREF(Py_None); resultobj = Py_None;
10458 {
10459 if (temp1)
10460 delete arg1;
10461 }
10462 return resultobj;
10463 fail:
10464 {
10465 if (temp1)
10466 delete arg1;
10467 }
10468 return NULL;
10469 }
10470
10471
10472 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10473 PyObject *resultobj;
10474 unsigned long arg1 ;
10475 wxString *arg2 = 0 ;
10476 bool temp2 = false ;
10477 PyObject * obj0 = 0 ;
10478 PyObject * obj1 = 0 ;
10479 char *kwnames[] = {
10480 (char *) "level",(char *) "msg", NULL
10481 };
10482
10483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10484 {
10485 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10486 if (SWIG_arg_fail(1)) SWIG_fail;
10487 }
10488 {
10489 arg2 = wxString_in_helper(obj1);
10490 if (arg2 == NULL) SWIG_fail;
10491 temp2 = true;
10492 }
10493 {
10494 PyThreadState* __tstate = wxPyBeginAllowThreads();
10495 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10496
10497 wxPyEndAllowThreads(__tstate);
10498 if (PyErr_Occurred()) SWIG_fail;
10499 }
10500 Py_INCREF(Py_None); resultobj = Py_None;
10501 {
10502 if (temp2)
10503 delete arg2;
10504 }
10505 return resultobj;
10506 fail:
10507 {
10508 if (temp2)
10509 delete arg2;
10510 }
10511 return NULL;
10512 }
10513
10514
10515 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10516 PyObject *resultobj;
10517 unsigned long arg1 ;
10518 wxString *arg2 = 0 ;
10519 bool temp2 = false ;
10520 PyObject * obj0 = 0 ;
10521 PyObject * obj1 = 0 ;
10522
10523 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10524 {
10525 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10526 if (SWIG_arg_fail(1)) SWIG_fail;
10527 }
10528 {
10529 arg2 = wxString_in_helper(obj1);
10530 if (arg2 == NULL) SWIG_fail;
10531 temp2 = true;
10532 }
10533 {
10534 PyThreadState* __tstate = wxPyBeginAllowThreads();
10535 wxPyLogTrace(arg1,(wxString const &)*arg2);
10536
10537 wxPyEndAllowThreads(__tstate);
10538 if (PyErr_Occurred()) SWIG_fail;
10539 }
10540 Py_INCREF(Py_None); resultobj = Py_None;
10541 {
10542 if (temp2)
10543 delete arg2;
10544 }
10545 return resultobj;
10546 fail:
10547 {
10548 if (temp2)
10549 delete arg2;
10550 }
10551 return NULL;
10552 }
10553
10554
10555 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10556 PyObject *resultobj;
10557 wxString *arg1 = 0 ;
10558 wxString *arg2 = 0 ;
10559 bool temp1 = false ;
10560 bool temp2 = false ;
10561 PyObject * obj0 = 0 ;
10562 PyObject * obj1 = 0 ;
10563
10564 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10565 {
10566 arg1 = wxString_in_helper(obj0);
10567 if (arg1 == NULL) SWIG_fail;
10568 temp1 = true;
10569 }
10570 {
10571 arg2 = wxString_in_helper(obj1);
10572 if (arg2 == NULL) SWIG_fail;
10573 temp2 = true;
10574 }
10575 {
10576 PyThreadState* __tstate = wxPyBeginAllowThreads();
10577 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10578
10579 wxPyEndAllowThreads(__tstate);
10580 if (PyErr_Occurred()) SWIG_fail;
10581 }
10582 Py_INCREF(Py_None); resultobj = Py_None;
10583 {
10584 if (temp1)
10585 delete arg1;
10586 }
10587 {
10588 if (temp2)
10589 delete arg2;
10590 }
10591 return resultobj;
10592 fail:
10593 {
10594 if (temp1)
10595 delete arg1;
10596 }
10597 {
10598 if (temp2)
10599 delete arg2;
10600 }
10601 return NULL;
10602 }
10603
10604
10605 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10606 int argc;
10607 PyObject *argv[3];
10608 int ii;
10609
10610 argc = PyObject_Length(args);
10611 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10612 argv[ii] = PyTuple_GetItem(args,ii);
10613 }
10614 if (argc == 2) {
10615 int _v;
10616 {
10617 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10618 }
10619 if (_v) {
10620 {
10621 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10622 }
10623 if (_v) {
10624 return _wrap_LogTrace__SWIG_1(self,args);
10625 }
10626 }
10627 }
10628 if (argc == 2) {
10629 int _v;
10630 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10631 if (_v) {
10632 {
10633 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10634 }
10635 if (_v) {
10636 return _wrap_LogTrace__SWIG_0(self,args);
10637 }
10638 }
10639 }
10640
10641 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10642 return NULL;
10643 }
10644
10645
10646 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10647 PyObject *resultobj;
10648 wxString *arg1 = 0 ;
10649 wxString *arg2 = 0 ;
10650 bool temp1 = false ;
10651 bool temp2 = false ;
10652 PyObject * obj0 = 0 ;
10653 PyObject * obj1 = 0 ;
10654 char *kwnames[] = {
10655 (char *) "title",(char *) "text", NULL
10656 };
10657
10658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10659 {
10660 arg1 = wxString_in_helper(obj0);
10661 if (arg1 == NULL) SWIG_fail;
10662 temp1 = true;
10663 }
10664 {
10665 arg2 = wxString_in_helper(obj1);
10666 if (arg2 == NULL) SWIG_fail;
10667 temp2 = true;
10668 }
10669 {
10670 PyThreadState* __tstate = wxPyBeginAllowThreads();
10671 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10672
10673 wxPyEndAllowThreads(__tstate);
10674 if (PyErr_Occurred()) SWIG_fail;
10675 }
10676 Py_INCREF(Py_None); resultobj = Py_None;
10677 {
10678 if (temp1)
10679 delete arg1;
10680 }
10681 {
10682 if (temp2)
10683 delete arg2;
10684 }
10685 return resultobj;
10686 fail:
10687 {
10688 if (temp1)
10689 delete arg1;
10690 }
10691 {
10692 if (temp2)
10693 delete arg2;
10694 }
10695 return NULL;
10696 }
10697
10698
10699 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10700 PyObject *resultobj;
10701 wxLogNull *result;
10702 char *kwnames[] = {
10703 NULL
10704 };
10705
10706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10707 {
10708 PyThreadState* __tstate = wxPyBeginAllowThreads();
10709 result = (wxLogNull *)new wxLogNull();
10710
10711 wxPyEndAllowThreads(__tstate);
10712 if (PyErr_Occurred()) SWIG_fail;
10713 }
10714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10715 return resultobj;
10716 fail:
10717 return NULL;
10718 }
10719
10720
10721 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10722 PyObject *resultobj;
10723 wxLogNull *arg1 = (wxLogNull *) 0 ;
10724 PyObject * obj0 = 0 ;
10725 char *kwnames[] = {
10726 (char *) "self", NULL
10727 };
10728
10729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10731 if (SWIG_arg_fail(1)) SWIG_fail;
10732 {
10733 PyThreadState* __tstate = wxPyBeginAllowThreads();
10734 delete arg1;
10735
10736 wxPyEndAllowThreads(__tstate);
10737 if (PyErr_Occurred()) SWIG_fail;
10738 }
10739 Py_INCREF(Py_None); resultobj = Py_None;
10740 return resultobj;
10741 fail:
10742 return NULL;
10743 }
10744
10745
10746 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10747 PyObject *obj;
10748 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10749 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10750 Py_INCREF(obj);
10751 return Py_BuildValue((char *)"");
10752 }
10753 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10754 PyObject *resultobj;
10755 wxPyLog *result;
10756 char *kwnames[] = {
10757 NULL
10758 };
10759
10760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10761 {
10762 PyThreadState* __tstate = wxPyBeginAllowThreads();
10763 result = (wxPyLog *)new wxPyLog();
10764
10765 wxPyEndAllowThreads(__tstate);
10766 if (PyErr_Occurred()) SWIG_fail;
10767 }
10768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10769 return resultobj;
10770 fail:
10771 return NULL;
10772 }
10773
10774
10775 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10776 PyObject *resultobj;
10777 wxPyLog *arg1 = (wxPyLog *) 0 ;
10778 PyObject *arg2 = (PyObject *) 0 ;
10779 PyObject *arg3 = (PyObject *) 0 ;
10780 PyObject * obj0 = 0 ;
10781 PyObject * obj1 = 0 ;
10782 PyObject * obj2 = 0 ;
10783 char *kwnames[] = {
10784 (char *) "self",(char *) "self",(char *) "_class", NULL
10785 };
10786
10787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10789 if (SWIG_arg_fail(1)) SWIG_fail;
10790 arg2 = obj1;
10791 arg3 = obj2;
10792 {
10793 PyThreadState* __tstate = wxPyBeginAllowThreads();
10794 (arg1)->_setCallbackInfo(arg2,arg3);
10795
10796 wxPyEndAllowThreads(__tstate);
10797 if (PyErr_Occurred()) SWIG_fail;
10798 }
10799 Py_INCREF(Py_None); resultobj = Py_None;
10800 return resultobj;
10801 fail:
10802 return NULL;
10803 }
10804
10805
10806 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10807 PyObject *obj;
10808 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10809 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10810 Py_INCREF(obj);
10811 return Py_BuildValue((char *)"");
10812 }
10813 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10814 PyObject *resultobj;
10815 int arg1 ;
10816 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10817 int arg3 = (int) wxKILL_NOCHILDREN ;
10818 wxKillError result;
10819 PyObject * obj0 = 0 ;
10820 PyObject * obj1 = 0 ;
10821 PyObject * obj2 = 0 ;
10822 char *kwnames[] = {
10823 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10824 };
10825
10826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10827 {
10828 arg1 = (int)(SWIG_As_int(obj0));
10829 if (SWIG_arg_fail(1)) SWIG_fail;
10830 }
10831 if (obj1) {
10832 {
10833 arg2 = (wxSignal)(SWIG_As_int(obj1));
10834 if (SWIG_arg_fail(2)) SWIG_fail;
10835 }
10836 }
10837 if (obj2) {
10838 {
10839 arg3 = (int)(SWIG_As_int(obj2));
10840 if (SWIG_arg_fail(3)) SWIG_fail;
10841 }
10842 }
10843 {
10844 PyThreadState* __tstate = wxPyBeginAllowThreads();
10845 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10846
10847 wxPyEndAllowThreads(__tstate);
10848 if (PyErr_Occurred()) SWIG_fail;
10849 }
10850 resultobj = SWIG_From_int((result));
10851 return resultobj;
10852 fail:
10853 return NULL;
10854 }
10855
10856
10857 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10858 PyObject *resultobj;
10859 int arg1 ;
10860 bool result;
10861 PyObject * obj0 = 0 ;
10862 char *kwnames[] = {
10863 (char *) "pid", NULL
10864 };
10865
10866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10867 {
10868 arg1 = (int)(SWIG_As_int(obj0));
10869 if (SWIG_arg_fail(1)) SWIG_fail;
10870 }
10871 {
10872 PyThreadState* __tstate = wxPyBeginAllowThreads();
10873 result = (bool)wxPyProcess::Exists(arg1);
10874
10875 wxPyEndAllowThreads(__tstate);
10876 if (PyErr_Occurred()) SWIG_fail;
10877 }
10878 {
10879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10880 }
10881 return resultobj;
10882 fail:
10883 return NULL;
10884 }
10885
10886
10887 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10888 PyObject *resultobj;
10889 wxString *arg1 = 0 ;
10890 int arg2 = (int) wxEXEC_ASYNC ;
10891 wxPyProcess *result;
10892 bool temp1 = false ;
10893 PyObject * obj0 = 0 ;
10894 PyObject * obj1 = 0 ;
10895 char *kwnames[] = {
10896 (char *) "cmd",(char *) "flags", NULL
10897 };
10898
10899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10900 {
10901 arg1 = wxString_in_helper(obj0);
10902 if (arg1 == NULL) SWIG_fail;
10903 temp1 = true;
10904 }
10905 if (obj1) {
10906 {
10907 arg2 = (int)(SWIG_As_int(obj1));
10908 if (SWIG_arg_fail(2)) SWIG_fail;
10909 }
10910 }
10911 {
10912 PyThreadState* __tstate = wxPyBeginAllowThreads();
10913 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10914
10915 wxPyEndAllowThreads(__tstate);
10916 if (PyErr_Occurred()) SWIG_fail;
10917 }
10918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10919 {
10920 if (temp1)
10921 delete arg1;
10922 }
10923 return resultobj;
10924 fail:
10925 {
10926 if (temp1)
10927 delete arg1;
10928 }
10929 return NULL;
10930 }
10931
10932
10933 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10934 PyObject *resultobj;
10935 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10936 int arg2 = (int) -1 ;
10937 wxPyProcess *result;
10938 PyObject * obj0 = 0 ;
10939 PyObject * obj1 = 0 ;
10940 char *kwnames[] = {
10941 (char *) "parent",(char *) "id", NULL
10942 };
10943
10944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10945 if (obj0) {
10946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10947 if (SWIG_arg_fail(1)) SWIG_fail;
10948 }
10949 if (obj1) {
10950 {
10951 arg2 = (int)(SWIG_As_int(obj1));
10952 if (SWIG_arg_fail(2)) SWIG_fail;
10953 }
10954 }
10955 {
10956 PyThreadState* __tstate = wxPyBeginAllowThreads();
10957 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10958
10959 wxPyEndAllowThreads(__tstate);
10960 if (PyErr_Occurred()) SWIG_fail;
10961 }
10962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10963 return resultobj;
10964 fail:
10965 return NULL;
10966 }
10967
10968
10969 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10970 PyObject *resultobj;
10971 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10972 PyObject *arg2 = (PyObject *) 0 ;
10973 PyObject *arg3 = (PyObject *) 0 ;
10974 PyObject * obj0 = 0 ;
10975 PyObject * obj1 = 0 ;
10976 PyObject * obj2 = 0 ;
10977 char *kwnames[] = {
10978 (char *) "self",(char *) "self",(char *) "_class", NULL
10979 };
10980
10981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10983 if (SWIG_arg_fail(1)) SWIG_fail;
10984 arg2 = obj1;
10985 arg3 = obj2;
10986 {
10987 PyThreadState* __tstate = wxPyBeginAllowThreads();
10988 (arg1)->_setCallbackInfo(arg2,arg3);
10989
10990 wxPyEndAllowThreads(__tstate);
10991 if (PyErr_Occurred()) SWIG_fail;
10992 }
10993 Py_INCREF(Py_None); resultobj = Py_None;
10994 return resultobj;
10995 fail:
10996 return NULL;
10997 }
10998
10999
11000 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
11001 PyObject *resultobj;
11002 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11003 int arg2 ;
11004 int arg3 ;
11005 PyObject * obj0 = 0 ;
11006 PyObject * obj1 = 0 ;
11007 PyObject * obj2 = 0 ;
11008 char *kwnames[] = {
11009 (char *) "self",(char *) "pid",(char *) "status", NULL
11010 };
11011
11012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
11013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11014 if (SWIG_arg_fail(1)) SWIG_fail;
11015 {
11016 arg2 = (int)(SWIG_As_int(obj1));
11017 if (SWIG_arg_fail(2)) SWIG_fail;
11018 }
11019 {
11020 arg3 = (int)(SWIG_As_int(obj2));
11021 if (SWIG_arg_fail(3)) SWIG_fail;
11022 }
11023 {
11024 PyThreadState* __tstate = wxPyBeginAllowThreads();
11025 (arg1)->base_OnTerminate(arg2,arg3);
11026
11027 wxPyEndAllowThreads(__tstate);
11028 if (PyErr_Occurred()) SWIG_fail;
11029 }
11030 Py_INCREF(Py_None); resultobj = Py_None;
11031 return resultobj;
11032 fail:
11033 return NULL;
11034 }
11035
11036
11037 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11038 PyObject *resultobj;
11039 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11040 PyObject * obj0 = 0 ;
11041 char *kwnames[] = {
11042 (char *) "self", NULL
11043 };
11044
11045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11047 if (SWIG_arg_fail(1)) SWIG_fail;
11048 {
11049 PyThreadState* __tstate = wxPyBeginAllowThreads();
11050 (arg1)->Redirect();
11051
11052 wxPyEndAllowThreads(__tstate);
11053 if (PyErr_Occurred()) SWIG_fail;
11054 }
11055 Py_INCREF(Py_None); resultobj = Py_None;
11056 return resultobj;
11057 fail:
11058 return NULL;
11059 }
11060
11061
11062 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11063 PyObject *resultobj;
11064 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11065 bool result;
11066 PyObject * obj0 = 0 ;
11067 char *kwnames[] = {
11068 (char *) "self", NULL
11069 };
11070
11071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11073 if (SWIG_arg_fail(1)) SWIG_fail;
11074 {
11075 PyThreadState* __tstate = wxPyBeginAllowThreads();
11076 result = (bool)(arg1)->IsRedirected();
11077
11078 wxPyEndAllowThreads(__tstate);
11079 if (PyErr_Occurred()) SWIG_fail;
11080 }
11081 {
11082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11083 }
11084 return resultobj;
11085 fail:
11086 return NULL;
11087 }
11088
11089
11090 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11091 PyObject *resultobj;
11092 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11093 PyObject * obj0 = 0 ;
11094 char *kwnames[] = {
11095 (char *) "self", NULL
11096 };
11097
11098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11100 if (SWIG_arg_fail(1)) SWIG_fail;
11101 {
11102 PyThreadState* __tstate = wxPyBeginAllowThreads();
11103 (arg1)->Detach();
11104
11105 wxPyEndAllowThreads(__tstate);
11106 if (PyErr_Occurred()) SWIG_fail;
11107 }
11108 Py_INCREF(Py_None); resultobj = Py_None;
11109 return resultobj;
11110 fail:
11111 return NULL;
11112 }
11113
11114
11115 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11116 PyObject *resultobj;
11117 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11118 wxInputStream *result;
11119 PyObject * obj0 = 0 ;
11120 char *kwnames[] = {
11121 (char *) "self", NULL
11122 };
11123
11124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11126 if (SWIG_arg_fail(1)) SWIG_fail;
11127 {
11128 PyThreadState* __tstate = wxPyBeginAllowThreads();
11129 result = (wxInputStream *)(arg1)->GetInputStream();
11130
11131 wxPyEndAllowThreads(__tstate);
11132 if (PyErr_Occurred()) SWIG_fail;
11133 }
11134 {
11135 wxPyInputStream * _ptr = NULL;
11136
11137 if (result) {
11138 _ptr = new wxPyInputStream(result);
11139 }
11140 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11141 }
11142 return resultobj;
11143 fail:
11144 return NULL;
11145 }
11146
11147
11148 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11149 PyObject *resultobj;
11150 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11151 wxInputStream *result;
11152 PyObject * obj0 = 0 ;
11153 char *kwnames[] = {
11154 (char *) "self", NULL
11155 };
11156
11157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11159 if (SWIG_arg_fail(1)) SWIG_fail;
11160 {
11161 PyThreadState* __tstate = wxPyBeginAllowThreads();
11162 result = (wxInputStream *)(arg1)->GetErrorStream();
11163
11164 wxPyEndAllowThreads(__tstate);
11165 if (PyErr_Occurred()) SWIG_fail;
11166 }
11167 {
11168 wxPyInputStream * _ptr = NULL;
11169
11170 if (result) {
11171 _ptr = new wxPyInputStream(result);
11172 }
11173 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11174 }
11175 return resultobj;
11176 fail:
11177 return NULL;
11178 }
11179
11180
11181 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11182 PyObject *resultobj;
11183 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11184 wxOutputStream *result;
11185 PyObject * obj0 = 0 ;
11186 char *kwnames[] = {
11187 (char *) "self", NULL
11188 };
11189
11190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11192 if (SWIG_arg_fail(1)) SWIG_fail;
11193 {
11194 PyThreadState* __tstate = wxPyBeginAllowThreads();
11195 result = (wxOutputStream *)(arg1)->GetOutputStream();
11196
11197 wxPyEndAllowThreads(__tstate);
11198 if (PyErr_Occurred()) SWIG_fail;
11199 }
11200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11201 return resultobj;
11202 fail:
11203 return NULL;
11204 }
11205
11206
11207 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11208 PyObject *resultobj;
11209 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11210 PyObject * obj0 = 0 ;
11211 char *kwnames[] = {
11212 (char *) "self", NULL
11213 };
11214
11215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11217 if (SWIG_arg_fail(1)) SWIG_fail;
11218 {
11219 PyThreadState* __tstate = wxPyBeginAllowThreads();
11220 (arg1)->CloseOutput();
11221
11222 wxPyEndAllowThreads(__tstate);
11223 if (PyErr_Occurred()) SWIG_fail;
11224 }
11225 Py_INCREF(Py_None); resultobj = Py_None;
11226 return resultobj;
11227 fail:
11228 return NULL;
11229 }
11230
11231
11232 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11233 PyObject *resultobj;
11234 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11235 bool result;
11236 PyObject * obj0 = 0 ;
11237 char *kwnames[] = {
11238 (char *) "self", NULL
11239 };
11240
11241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11243 if (SWIG_arg_fail(1)) SWIG_fail;
11244 {
11245 PyThreadState* __tstate = wxPyBeginAllowThreads();
11246 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11247
11248 wxPyEndAllowThreads(__tstate);
11249 if (PyErr_Occurred()) SWIG_fail;
11250 }
11251 {
11252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11253 }
11254 return resultobj;
11255 fail:
11256 return NULL;
11257 }
11258
11259
11260 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11261 PyObject *resultobj;
11262 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11263 bool result;
11264 PyObject * obj0 = 0 ;
11265 char *kwnames[] = {
11266 (char *) "self", NULL
11267 };
11268
11269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11271 if (SWIG_arg_fail(1)) SWIG_fail;
11272 {
11273 PyThreadState* __tstate = wxPyBeginAllowThreads();
11274 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11275
11276 wxPyEndAllowThreads(__tstate);
11277 if (PyErr_Occurred()) SWIG_fail;
11278 }
11279 {
11280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11281 }
11282 return resultobj;
11283 fail:
11284 return NULL;
11285 }
11286
11287
11288 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11289 PyObject *resultobj;
11290 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11291 bool result;
11292 PyObject * obj0 = 0 ;
11293 char *kwnames[] = {
11294 (char *) "self", NULL
11295 };
11296
11297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11299 if (SWIG_arg_fail(1)) SWIG_fail;
11300 {
11301 PyThreadState* __tstate = wxPyBeginAllowThreads();
11302 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11303
11304 wxPyEndAllowThreads(__tstate);
11305 if (PyErr_Occurred()) SWIG_fail;
11306 }
11307 {
11308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11309 }
11310 return resultobj;
11311 fail:
11312 return NULL;
11313 }
11314
11315
11316 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11317 PyObject *obj;
11318 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11319 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11320 Py_INCREF(obj);
11321 return Py_BuildValue((char *)"");
11322 }
11323 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11324 PyObject *resultobj;
11325 int arg1 = (int) 0 ;
11326 int arg2 = (int) 0 ;
11327 int arg3 = (int) 0 ;
11328 wxProcessEvent *result;
11329 PyObject * obj0 = 0 ;
11330 PyObject * obj1 = 0 ;
11331 PyObject * obj2 = 0 ;
11332 char *kwnames[] = {
11333 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11334 };
11335
11336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11337 if (obj0) {
11338 {
11339 arg1 = (int)(SWIG_As_int(obj0));
11340 if (SWIG_arg_fail(1)) SWIG_fail;
11341 }
11342 }
11343 if (obj1) {
11344 {
11345 arg2 = (int)(SWIG_As_int(obj1));
11346 if (SWIG_arg_fail(2)) SWIG_fail;
11347 }
11348 }
11349 if (obj2) {
11350 {
11351 arg3 = (int)(SWIG_As_int(obj2));
11352 if (SWIG_arg_fail(3)) SWIG_fail;
11353 }
11354 }
11355 {
11356 PyThreadState* __tstate = wxPyBeginAllowThreads();
11357 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11358
11359 wxPyEndAllowThreads(__tstate);
11360 if (PyErr_Occurred()) SWIG_fail;
11361 }
11362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11363 return resultobj;
11364 fail:
11365 return NULL;
11366 }
11367
11368
11369 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11370 PyObject *resultobj;
11371 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11372 int result;
11373 PyObject * obj0 = 0 ;
11374 char *kwnames[] = {
11375 (char *) "self", NULL
11376 };
11377
11378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11380 if (SWIG_arg_fail(1)) SWIG_fail;
11381 {
11382 PyThreadState* __tstate = wxPyBeginAllowThreads();
11383 result = (int)(arg1)->GetPid();
11384
11385 wxPyEndAllowThreads(__tstate);
11386 if (PyErr_Occurred()) SWIG_fail;
11387 }
11388 {
11389 resultobj = SWIG_From_int((int)(result));
11390 }
11391 return resultobj;
11392 fail:
11393 return NULL;
11394 }
11395
11396
11397 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11398 PyObject *resultobj;
11399 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11400 int result;
11401 PyObject * obj0 = 0 ;
11402 char *kwnames[] = {
11403 (char *) "self", NULL
11404 };
11405
11406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11408 if (SWIG_arg_fail(1)) SWIG_fail;
11409 {
11410 PyThreadState* __tstate = wxPyBeginAllowThreads();
11411 result = (int)(arg1)->GetExitCode();
11412
11413 wxPyEndAllowThreads(__tstate);
11414 if (PyErr_Occurred()) SWIG_fail;
11415 }
11416 {
11417 resultobj = SWIG_From_int((int)(result));
11418 }
11419 return resultobj;
11420 fail:
11421 return NULL;
11422 }
11423
11424
11425 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11426 PyObject *resultobj;
11427 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11428 int arg2 ;
11429 PyObject * obj0 = 0 ;
11430 PyObject * obj1 = 0 ;
11431 char *kwnames[] = {
11432 (char *) "self",(char *) "m_pid", NULL
11433 };
11434
11435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11437 if (SWIG_arg_fail(1)) SWIG_fail;
11438 {
11439 arg2 = (int)(SWIG_As_int(obj1));
11440 if (SWIG_arg_fail(2)) SWIG_fail;
11441 }
11442 if (arg1) (arg1)->m_pid = arg2;
11443
11444 Py_INCREF(Py_None); resultobj = Py_None;
11445 return resultobj;
11446 fail:
11447 return NULL;
11448 }
11449
11450
11451 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11452 PyObject *resultobj;
11453 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11454 int result;
11455 PyObject * obj0 = 0 ;
11456 char *kwnames[] = {
11457 (char *) "self", NULL
11458 };
11459
11460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11462 if (SWIG_arg_fail(1)) SWIG_fail;
11463 result = (int) ((arg1)->m_pid);
11464
11465 {
11466 resultobj = SWIG_From_int((int)(result));
11467 }
11468 return resultobj;
11469 fail:
11470 return NULL;
11471 }
11472
11473
11474 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11475 PyObject *resultobj;
11476 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11477 int arg2 ;
11478 PyObject * obj0 = 0 ;
11479 PyObject * obj1 = 0 ;
11480 char *kwnames[] = {
11481 (char *) "self",(char *) "m_exitcode", NULL
11482 };
11483
11484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11486 if (SWIG_arg_fail(1)) SWIG_fail;
11487 {
11488 arg2 = (int)(SWIG_As_int(obj1));
11489 if (SWIG_arg_fail(2)) SWIG_fail;
11490 }
11491 if (arg1) (arg1)->m_exitcode = arg2;
11492
11493 Py_INCREF(Py_None); resultobj = Py_None;
11494 return resultobj;
11495 fail:
11496 return NULL;
11497 }
11498
11499
11500 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11501 PyObject *resultobj;
11502 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11503 int result;
11504 PyObject * obj0 = 0 ;
11505 char *kwnames[] = {
11506 (char *) "self", NULL
11507 };
11508
11509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11511 if (SWIG_arg_fail(1)) SWIG_fail;
11512 result = (int) ((arg1)->m_exitcode);
11513
11514 {
11515 resultobj = SWIG_From_int((int)(result));
11516 }
11517 return resultobj;
11518 fail:
11519 return NULL;
11520 }
11521
11522
11523 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11524 PyObject *obj;
11525 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11526 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11527 Py_INCREF(obj);
11528 return Py_BuildValue((char *)"");
11529 }
11530 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11531 PyObject *resultobj;
11532 wxString *arg1 = 0 ;
11533 int arg2 = (int) wxEXEC_ASYNC ;
11534 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11535 long result;
11536 bool temp1 = false ;
11537 PyObject * obj0 = 0 ;
11538 PyObject * obj1 = 0 ;
11539 PyObject * obj2 = 0 ;
11540 char *kwnames[] = {
11541 (char *) "command",(char *) "flags",(char *) "process", NULL
11542 };
11543
11544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11545 {
11546 arg1 = wxString_in_helper(obj0);
11547 if (arg1 == NULL) SWIG_fail;
11548 temp1 = true;
11549 }
11550 if (obj1) {
11551 {
11552 arg2 = (int)(SWIG_As_int(obj1));
11553 if (SWIG_arg_fail(2)) SWIG_fail;
11554 }
11555 }
11556 if (obj2) {
11557 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11558 if (SWIG_arg_fail(3)) SWIG_fail;
11559 }
11560 {
11561 if (!wxPyCheckForApp()) SWIG_fail;
11562 PyThreadState* __tstate = wxPyBeginAllowThreads();
11563 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11564
11565 wxPyEndAllowThreads(__tstate);
11566 if (PyErr_Occurred()) SWIG_fail;
11567 }
11568 {
11569 resultobj = SWIG_From_long((long)(result));
11570 }
11571 {
11572 if (temp1)
11573 delete arg1;
11574 }
11575 return resultobj;
11576 fail:
11577 {
11578 if (temp1)
11579 delete arg1;
11580 }
11581 return NULL;
11582 }
11583
11584
11585 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11586 PyObject *resultobj;
11587 long arg1 ;
11588 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11589 wxKillError *arg3 = (wxKillError *) 0 ;
11590 int arg4 = (int) wxKILL_NOCHILDREN ;
11591 int result;
11592 wxKillError temp3 ;
11593 PyObject * obj0 = 0 ;
11594 PyObject * obj1 = 0 ;
11595 PyObject * obj2 = 0 ;
11596 char *kwnames[] = {
11597 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11598 };
11599
11600 {
11601 arg3 = &temp3;
11602 }
11603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11604 {
11605 arg1 = (long)(SWIG_As_long(obj0));
11606 if (SWIG_arg_fail(1)) SWIG_fail;
11607 }
11608 if (obj1) {
11609 {
11610 arg2 = (wxSignal)(SWIG_As_int(obj1));
11611 if (SWIG_arg_fail(2)) SWIG_fail;
11612 }
11613 }
11614 if (obj2) {
11615 {
11616 arg4 = (int)(SWIG_As_int(obj2));
11617 if (SWIG_arg_fail(4)) SWIG_fail;
11618 }
11619 }
11620 {
11621 PyThreadState* __tstate = wxPyBeginAllowThreads();
11622 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11623
11624 wxPyEndAllowThreads(__tstate);
11625 if (PyErr_Occurred()) SWIG_fail;
11626 }
11627 {
11628 resultobj = SWIG_From_int((int)(result));
11629 }
11630 {
11631 PyObject* o;
11632 o = PyInt_FromLong((long) (*arg3));
11633 resultobj = t_output_helper(resultobj, o);
11634 }
11635 return resultobj;
11636 fail:
11637 return NULL;
11638 }
11639
11640
11641 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11642 PyObject *resultobj;
11643 int arg1 = (int) wxJOYSTICK1 ;
11644 wxJoystick *result;
11645 PyObject * obj0 = 0 ;
11646 char *kwnames[] = {
11647 (char *) "joystick", NULL
11648 };
11649
11650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11651 if (obj0) {
11652 {
11653 arg1 = (int)(SWIG_As_int(obj0));
11654 if (SWIG_arg_fail(1)) SWIG_fail;
11655 }
11656 }
11657 {
11658 if (!wxPyCheckForApp()) SWIG_fail;
11659 PyThreadState* __tstate = wxPyBeginAllowThreads();
11660 result = (wxJoystick *)new wxJoystick(arg1);
11661
11662 wxPyEndAllowThreads(__tstate);
11663 if (PyErr_Occurred()) SWIG_fail;
11664 }
11665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11666 return resultobj;
11667 fail:
11668 return NULL;
11669 }
11670
11671
11672 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11673 PyObject *resultobj;
11674 wxJoystick *arg1 = (wxJoystick *) 0 ;
11675 PyObject * obj0 = 0 ;
11676 char *kwnames[] = {
11677 (char *) "self", NULL
11678 };
11679
11680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11682 if (SWIG_arg_fail(1)) SWIG_fail;
11683 {
11684 PyThreadState* __tstate = wxPyBeginAllowThreads();
11685 delete arg1;
11686
11687 wxPyEndAllowThreads(__tstate);
11688 if (PyErr_Occurred()) SWIG_fail;
11689 }
11690 Py_INCREF(Py_None); resultobj = Py_None;
11691 return resultobj;
11692 fail:
11693 return NULL;
11694 }
11695
11696
11697 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11698 PyObject *resultobj;
11699 wxJoystick *arg1 = (wxJoystick *) 0 ;
11700 wxPoint result;
11701 PyObject * obj0 = 0 ;
11702 char *kwnames[] = {
11703 (char *) "self", NULL
11704 };
11705
11706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11708 if (SWIG_arg_fail(1)) SWIG_fail;
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (arg1)->GetPosition();
11712
11713 wxPyEndAllowThreads(__tstate);
11714 if (PyErr_Occurred()) SWIG_fail;
11715 }
11716 {
11717 wxPoint * resultptr;
11718 resultptr = new wxPoint((wxPoint &)(result));
11719 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11720 }
11721 return resultobj;
11722 fail:
11723 return NULL;
11724 }
11725
11726
11727 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11728 PyObject *resultobj;
11729 wxJoystick *arg1 = (wxJoystick *) 0 ;
11730 int result;
11731 PyObject * obj0 = 0 ;
11732 char *kwnames[] = {
11733 (char *) "self", NULL
11734 };
11735
11736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11738 if (SWIG_arg_fail(1)) SWIG_fail;
11739 {
11740 PyThreadState* __tstate = wxPyBeginAllowThreads();
11741 result = (int)(arg1)->GetZPosition();
11742
11743 wxPyEndAllowThreads(__tstate);
11744 if (PyErr_Occurred()) SWIG_fail;
11745 }
11746 {
11747 resultobj = SWIG_From_int((int)(result));
11748 }
11749 return resultobj;
11750 fail:
11751 return NULL;
11752 }
11753
11754
11755 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11756 PyObject *resultobj;
11757 wxJoystick *arg1 = (wxJoystick *) 0 ;
11758 int result;
11759 PyObject * obj0 = 0 ;
11760 char *kwnames[] = {
11761 (char *) "self", NULL
11762 };
11763
11764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11766 if (SWIG_arg_fail(1)) SWIG_fail;
11767 {
11768 PyThreadState* __tstate = wxPyBeginAllowThreads();
11769 result = (int)(arg1)->GetButtonState();
11770
11771 wxPyEndAllowThreads(__tstate);
11772 if (PyErr_Occurred()) SWIG_fail;
11773 }
11774 {
11775 resultobj = SWIG_From_int((int)(result));
11776 }
11777 return resultobj;
11778 fail:
11779 return NULL;
11780 }
11781
11782
11783 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11784 PyObject *resultobj;
11785 wxJoystick *arg1 = (wxJoystick *) 0 ;
11786 int result;
11787 PyObject * obj0 = 0 ;
11788 char *kwnames[] = {
11789 (char *) "self", NULL
11790 };
11791
11792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11794 if (SWIG_arg_fail(1)) SWIG_fail;
11795 {
11796 PyThreadState* __tstate = wxPyBeginAllowThreads();
11797 result = (int)(arg1)->GetPOVPosition();
11798
11799 wxPyEndAllowThreads(__tstate);
11800 if (PyErr_Occurred()) SWIG_fail;
11801 }
11802 {
11803 resultobj = SWIG_From_int((int)(result));
11804 }
11805 return resultobj;
11806 fail:
11807 return NULL;
11808 }
11809
11810
11811 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11812 PyObject *resultobj;
11813 wxJoystick *arg1 = (wxJoystick *) 0 ;
11814 int result;
11815 PyObject * obj0 = 0 ;
11816 char *kwnames[] = {
11817 (char *) "self", NULL
11818 };
11819
11820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11822 if (SWIG_arg_fail(1)) SWIG_fail;
11823 {
11824 PyThreadState* __tstate = wxPyBeginAllowThreads();
11825 result = (int)(arg1)->GetPOVCTSPosition();
11826
11827 wxPyEndAllowThreads(__tstate);
11828 if (PyErr_Occurred()) SWIG_fail;
11829 }
11830 {
11831 resultobj = SWIG_From_int((int)(result));
11832 }
11833 return resultobj;
11834 fail:
11835 return NULL;
11836 }
11837
11838
11839 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11840 PyObject *resultobj;
11841 wxJoystick *arg1 = (wxJoystick *) 0 ;
11842 int result;
11843 PyObject * obj0 = 0 ;
11844 char *kwnames[] = {
11845 (char *) "self", NULL
11846 };
11847
11848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11850 if (SWIG_arg_fail(1)) SWIG_fail;
11851 {
11852 PyThreadState* __tstate = wxPyBeginAllowThreads();
11853 result = (int)(arg1)->GetRudderPosition();
11854
11855 wxPyEndAllowThreads(__tstate);
11856 if (PyErr_Occurred()) SWIG_fail;
11857 }
11858 {
11859 resultobj = SWIG_From_int((int)(result));
11860 }
11861 return resultobj;
11862 fail:
11863 return NULL;
11864 }
11865
11866
11867 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11868 PyObject *resultobj;
11869 wxJoystick *arg1 = (wxJoystick *) 0 ;
11870 int result;
11871 PyObject * obj0 = 0 ;
11872 char *kwnames[] = {
11873 (char *) "self", NULL
11874 };
11875
11876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11878 if (SWIG_arg_fail(1)) SWIG_fail;
11879 {
11880 PyThreadState* __tstate = wxPyBeginAllowThreads();
11881 result = (int)(arg1)->GetUPosition();
11882
11883 wxPyEndAllowThreads(__tstate);
11884 if (PyErr_Occurred()) SWIG_fail;
11885 }
11886 {
11887 resultobj = SWIG_From_int((int)(result));
11888 }
11889 return resultobj;
11890 fail:
11891 return NULL;
11892 }
11893
11894
11895 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11896 PyObject *resultobj;
11897 wxJoystick *arg1 = (wxJoystick *) 0 ;
11898 int result;
11899 PyObject * obj0 = 0 ;
11900 char *kwnames[] = {
11901 (char *) "self", NULL
11902 };
11903
11904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11906 if (SWIG_arg_fail(1)) SWIG_fail;
11907 {
11908 PyThreadState* __tstate = wxPyBeginAllowThreads();
11909 result = (int)(arg1)->GetVPosition();
11910
11911 wxPyEndAllowThreads(__tstate);
11912 if (PyErr_Occurred()) SWIG_fail;
11913 }
11914 {
11915 resultobj = SWIG_From_int((int)(result));
11916 }
11917 return resultobj;
11918 fail:
11919 return NULL;
11920 }
11921
11922
11923 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11924 PyObject *resultobj;
11925 wxJoystick *arg1 = (wxJoystick *) 0 ;
11926 int result;
11927 PyObject * obj0 = 0 ;
11928 char *kwnames[] = {
11929 (char *) "self", NULL
11930 };
11931
11932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11934 if (SWIG_arg_fail(1)) SWIG_fail;
11935 {
11936 PyThreadState* __tstate = wxPyBeginAllowThreads();
11937 result = (int)(arg1)->GetMovementThreshold();
11938
11939 wxPyEndAllowThreads(__tstate);
11940 if (PyErr_Occurred()) SWIG_fail;
11941 }
11942 {
11943 resultobj = SWIG_From_int((int)(result));
11944 }
11945 return resultobj;
11946 fail:
11947 return NULL;
11948 }
11949
11950
11951 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11952 PyObject *resultobj;
11953 wxJoystick *arg1 = (wxJoystick *) 0 ;
11954 int arg2 ;
11955 PyObject * obj0 = 0 ;
11956 PyObject * obj1 = 0 ;
11957 char *kwnames[] = {
11958 (char *) "self",(char *) "threshold", NULL
11959 };
11960
11961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11963 if (SWIG_arg_fail(1)) SWIG_fail;
11964 {
11965 arg2 = (int)(SWIG_As_int(obj1));
11966 if (SWIG_arg_fail(2)) SWIG_fail;
11967 }
11968 {
11969 PyThreadState* __tstate = wxPyBeginAllowThreads();
11970 (arg1)->SetMovementThreshold(arg2);
11971
11972 wxPyEndAllowThreads(__tstate);
11973 if (PyErr_Occurred()) SWIG_fail;
11974 }
11975 Py_INCREF(Py_None); resultobj = Py_None;
11976 return resultobj;
11977 fail:
11978 return NULL;
11979 }
11980
11981
11982 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11983 PyObject *resultobj;
11984 wxJoystick *arg1 = (wxJoystick *) 0 ;
11985 bool result;
11986 PyObject * obj0 = 0 ;
11987 char *kwnames[] = {
11988 (char *) "self", NULL
11989 };
11990
11991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11993 if (SWIG_arg_fail(1)) SWIG_fail;
11994 {
11995 PyThreadState* __tstate = wxPyBeginAllowThreads();
11996 result = (bool)(arg1)->IsOk();
11997
11998 wxPyEndAllowThreads(__tstate);
11999 if (PyErr_Occurred()) SWIG_fail;
12000 }
12001 {
12002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12003 }
12004 return resultobj;
12005 fail:
12006 return NULL;
12007 }
12008
12009
12010 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
12011 PyObject *resultobj;
12012 wxJoystick *arg1 = (wxJoystick *) 0 ;
12013 int result;
12014 PyObject * obj0 = 0 ;
12015 char *kwnames[] = {
12016 (char *) "self", NULL
12017 };
12018
12019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
12020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12021 if (SWIG_arg_fail(1)) SWIG_fail;
12022 {
12023 PyThreadState* __tstate = wxPyBeginAllowThreads();
12024 result = (int)(arg1)->GetNumberJoysticks();
12025
12026 wxPyEndAllowThreads(__tstate);
12027 if (PyErr_Occurred()) SWIG_fail;
12028 }
12029 {
12030 resultobj = SWIG_From_int((int)(result));
12031 }
12032 return resultobj;
12033 fail:
12034 return NULL;
12035 }
12036
12037
12038 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12039 PyObject *resultobj;
12040 wxJoystick *arg1 = (wxJoystick *) 0 ;
12041 int result;
12042 PyObject * obj0 = 0 ;
12043 char *kwnames[] = {
12044 (char *) "self", NULL
12045 };
12046
12047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12049 if (SWIG_arg_fail(1)) SWIG_fail;
12050 {
12051 PyThreadState* __tstate = wxPyBeginAllowThreads();
12052 result = (int)(arg1)->GetManufacturerId();
12053
12054 wxPyEndAllowThreads(__tstate);
12055 if (PyErr_Occurred()) SWIG_fail;
12056 }
12057 {
12058 resultobj = SWIG_From_int((int)(result));
12059 }
12060 return resultobj;
12061 fail:
12062 return NULL;
12063 }
12064
12065
12066 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12067 PyObject *resultobj;
12068 wxJoystick *arg1 = (wxJoystick *) 0 ;
12069 int result;
12070 PyObject * obj0 = 0 ;
12071 char *kwnames[] = {
12072 (char *) "self", NULL
12073 };
12074
12075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12077 if (SWIG_arg_fail(1)) SWIG_fail;
12078 {
12079 PyThreadState* __tstate = wxPyBeginAllowThreads();
12080 result = (int)(arg1)->GetProductId();
12081
12082 wxPyEndAllowThreads(__tstate);
12083 if (PyErr_Occurred()) SWIG_fail;
12084 }
12085 {
12086 resultobj = SWIG_From_int((int)(result));
12087 }
12088 return resultobj;
12089 fail:
12090 return NULL;
12091 }
12092
12093
12094 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12095 PyObject *resultobj;
12096 wxJoystick *arg1 = (wxJoystick *) 0 ;
12097 wxString result;
12098 PyObject * obj0 = 0 ;
12099 char *kwnames[] = {
12100 (char *) "self", NULL
12101 };
12102
12103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12105 if (SWIG_arg_fail(1)) SWIG_fail;
12106 {
12107 PyThreadState* __tstate = wxPyBeginAllowThreads();
12108 result = (arg1)->GetProductName();
12109
12110 wxPyEndAllowThreads(__tstate);
12111 if (PyErr_Occurred()) SWIG_fail;
12112 }
12113 {
12114 #if wxUSE_UNICODE
12115 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12116 #else
12117 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12118 #endif
12119 }
12120 return resultobj;
12121 fail:
12122 return NULL;
12123 }
12124
12125
12126 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12127 PyObject *resultobj;
12128 wxJoystick *arg1 = (wxJoystick *) 0 ;
12129 int result;
12130 PyObject * obj0 = 0 ;
12131 char *kwnames[] = {
12132 (char *) "self", NULL
12133 };
12134
12135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12137 if (SWIG_arg_fail(1)) SWIG_fail;
12138 {
12139 PyThreadState* __tstate = wxPyBeginAllowThreads();
12140 result = (int)(arg1)->GetXMin();
12141
12142 wxPyEndAllowThreads(__tstate);
12143 if (PyErr_Occurred()) SWIG_fail;
12144 }
12145 {
12146 resultobj = SWIG_From_int((int)(result));
12147 }
12148 return resultobj;
12149 fail:
12150 return NULL;
12151 }
12152
12153
12154 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12155 PyObject *resultobj;
12156 wxJoystick *arg1 = (wxJoystick *) 0 ;
12157 int result;
12158 PyObject * obj0 = 0 ;
12159 char *kwnames[] = {
12160 (char *) "self", NULL
12161 };
12162
12163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12165 if (SWIG_arg_fail(1)) SWIG_fail;
12166 {
12167 PyThreadState* __tstate = wxPyBeginAllowThreads();
12168 result = (int)(arg1)->GetYMin();
12169
12170 wxPyEndAllowThreads(__tstate);
12171 if (PyErr_Occurred()) SWIG_fail;
12172 }
12173 {
12174 resultobj = SWIG_From_int((int)(result));
12175 }
12176 return resultobj;
12177 fail:
12178 return NULL;
12179 }
12180
12181
12182 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12183 PyObject *resultobj;
12184 wxJoystick *arg1 = (wxJoystick *) 0 ;
12185 int result;
12186 PyObject * obj0 = 0 ;
12187 char *kwnames[] = {
12188 (char *) "self", NULL
12189 };
12190
12191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12193 if (SWIG_arg_fail(1)) SWIG_fail;
12194 {
12195 PyThreadState* __tstate = wxPyBeginAllowThreads();
12196 result = (int)(arg1)->GetZMin();
12197
12198 wxPyEndAllowThreads(__tstate);
12199 if (PyErr_Occurred()) SWIG_fail;
12200 }
12201 {
12202 resultobj = SWIG_From_int((int)(result));
12203 }
12204 return resultobj;
12205 fail:
12206 return NULL;
12207 }
12208
12209
12210 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12211 PyObject *resultobj;
12212 wxJoystick *arg1 = (wxJoystick *) 0 ;
12213 int result;
12214 PyObject * obj0 = 0 ;
12215 char *kwnames[] = {
12216 (char *) "self", NULL
12217 };
12218
12219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12221 if (SWIG_arg_fail(1)) SWIG_fail;
12222 {
12223 PyThreadState* __tstate = wxPyBeginAllowThreads();
12224 result = (int)(arg1)->GetXMax();
12225
12226 wxPyEndAllowThreads(__tstate);
12227 if (PyErr_Occurred()) SWIG_fail;
12228 }
12229 {
12230 resultobj = SWIG_From_int((int)(result));
12231 }
12232 return resultobj;
12233 fail:
12234 return NULL;
12235 }
12236
12237
12238 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12239 PyObject *resultobj;
12240 wxJoystick *arg1 = (wxJoystick *) 0 ;
12241 int result;
12242 PyObject * obj0 = 0 ;
12243 char *kwnames[] = {
12244 (char *) "self", NULL
12245 };
12246
12247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12249 if (SWIG_arg_fail(1)) SWIG_fail;
12250 {
12251 PyThreadState* __tstate = wxPyBeginAllowThreads();
12252 result = (int)(arg1)->GetYMax();
12253
12254 wxPyEndAllowThreads(__tstate);
12255 if (PyErr_Occurred()) SWIG_fail;
12256 }
12257 {
12258 resultobj = SWIG_From_int((int)(result));
12259 }
12260 return resultobj;
12261 fail:
12262 return NULL;
12263 }
12264
12265
12266 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12267 PyObject *resultobj;
12268 wxJoystick *arg1 = (wxJoystick *) 0 ;
12269 int result;
12270 PyObject * obj0 = 0 ;
12271 char *kwnames[] = {
12272 (char *) "self", NULL
12273 };
12274
12275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12277 if (SWIG_arg_fail(1)) SWIG_fail;
12278 {
12279 PyThreadState* __tstate = wxPyBeginAllowThreads();
12280 result = (int)(arg1)->GetZMax();
12281
12282 wxPyEndAllowThreads(__tstate);
12283 if (PyErr_Occurred()) SWIG_fail;
12284 }
12285 {
12286 resultobj = SWIG_From_int((int)(result));
12287 }
12288 return resultobj;
12289 fail:
12290 return NULL;
12291 }
12292
12293
12294 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12295 PyObject *resultobj;
12296 wxJoystick *arg1 = (wxJoystick *) 0 ;
12297 int result;
12298 PyObject * obj0 = 0 ;
12299 char *kwnames[] = {
12300 (char *) "self", NULL
12301 };
12302
12303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12305 if (SWIG_arg_fail(1)) SWIG_fail;
12306 {
12307 PyThreadState* __tstate = wxPyBeginAllowThreads();
12308 result = (int)(arg1)->GetNumberButtons();
12309
12310 wxPyEndAllowThreads(__tstate);
12311 if (PyErr_Occurred()) SWIG_fail;
12312 }
12313 {
12314 resultobj = SWIG_From_int((int)(result));
12315 }
12316 return resultobj;
12317 fail:
12318 return NULL;
12319 }
12320
12321
12322 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12323 PyObject *resultobj;
12324 wxJoystick *arg1 = (wxJoystick *) 0 ;
12325 int result;
12326 PyObject * obj0 = 0 ;
12327 char *kwnames[] = {
12328 (char *) "self", NULL
12329 };
12330
12331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12333 if (SWIG_arg_fail(1)) SWIG_fail;
12334 {
12335 PyThreadState* __tstate = wxPyBeginAllowThreads();
12336 result = (int)(arg1)->GetNumberAxes();
12337
12338 wxPyEndAllowThreads(__tstate);
12339 if (PyErr_Occurred()) SWIG_fail;
12340 }
12341 {
12342 resultobj = SWIG_From_int((int)(result));
12343 }
12344 return resultobj;
12345 fail:
12346 return NULL;
12347 }
12348
12349
12350 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12351 PyObject *resultobj;
12352 wxJoystick *arg1 = (wxJoystick *) 0 ;
12353 int result;
12354 PyObject * obj0 = 0 ;
12355 char *kwnames[] = {
12356 (char *) "self", NULL
12357 };
12358
12359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12361 if (SWIG_arg_fail(1)) SWIG_fail;
12362 {
12363 PyThreadState* __tstate = wxPyBeginAllowThreads();
12364 result = (int)(arg1)->GetMaxButtons();
12365
12366 wxPyEndAllowThreads(__tstate);
12367 if (PyErr_Occurred()) SWIG_fail;
12368 }
12369 {
12370 resultobj = SWIG_From_int((int)(result));
12371 }
12372 return resultobj;
12373 fail:
12374 return NULL;
12375 }
12376
12377
12378 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12379 PyObject *resultobj;
12380 wxJoystick *arg1 = (wxJoystick *) 0 ;
12381 int result;
12382 PyObject * obj0 = 0 ;
12383 char *kwnames[] = {
12384 (char *) "self", NULL
12385 };
12386
12387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12389 if (SWIG_arg_fail(1)) SWIG_fail;
12390 {
12391 PyThreadState* __tstate = wxPyBeginAllowThreads();
12392 result = (int)(arg1)->GetMaxAxes();
12393
12394 wxPyEndAllowThreads(__tstate);
12395 if (PyErr_Occurred()) SWIG_fail;
12396 }
12397 {
12398 resultobj = SWIG_From_int((int)(result));
12399 }
12400 return resultobj;
12401 fail:
12402 return NULL;
12403 }
12404
12405
12406 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12407 PyObject *resultobj;
12408 wxJoystick *arg1 = (wxJoystick *) 0 ;
12409 int result;
12410 PyObject * obj0 = 0 ;
12411 char *kwnames[] = {
12412 (char *) "self", NULL
12413 };
12414
12415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12417 if (SWIG_arg_fail(1)) SWIG_fail;
12418 {
12419 PyThreadState* __tstate = wxPyBeginAllowThreads();
12420 result = (int)(arg1)->GetPollingMin();
12421
12422 wxPyEndAllowThreads(__tstate);
12423 if (PyErr_Occurred()) SWIG_fail;
12424 }
12425 {
12426 resultobj = SWIG_From_int((int)(result));
12427 }
12428 return resultobj;
12429 fail:
12430 return NULL;
12431 }
12432
12433
12434 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12435 PyObject *resultobj;
12436 wxJoystick *arg1 = (wxJoystick *) 0 ;
12437 int result;
12438 PyObject * obj0 = 0 ;
12439 char *kwnames[] = {
12440 (char *) "self", NULL
12441 };
12442
12443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12445 if (SWIG_arg_fail(1)) SWIG_fail;
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 result = (int)(arg1)->GetPollingMax();
12449
12450 wxPyEndAllowThreads(__tstate);
12451 if (PyErr_Occurred()) SWIG_fail;
12452 }
12453 {
12454 resultobj = SWIG_From_int((int)(result));
12455 }
12456 return resultobj;
12457 fail:
12458 return NULL;
12459 }
12460
12461
12462 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12463 PyObject *resultobj;
12464 wxJoystick *arg1 = (wxJoystick *) 0 ;
12465 int result;
12466 PyObject * obj0 = 0 ;
12467 char *kwnames[] = {
12468 (char *) "self", NULL
12469 };
12470
12471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12473 if (SWIG_arg_fail(1)) SWIG_fail;
12474 {
12475 PyThreadState* __tstate = wxPyBeginAllowThreads();
12476 result = (int)(arg1)->GetRudderMin();
12477
12478 wxPyEndAllowThreads(__tstate);
12479 if (PyErr_Occurred()) SWIG_fail;
12480 }
12481 {
12482 resultobj = SWIG_From_int((int)(result));
12483 }
12484 return resultobj;
12485 fail:
12486 return NULL;
12487 }
12488
12489
12490 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12491 PyObject *resultobj;
12492 wxJoystick *arg1 = (wxJoystick *) 0 ;
12493 int result;
12494 PyObject * obj0 = 0 ;
12495 char *kwnames[] = {
12496 (char *) "self", NULL
12497 };
12498
12499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12501 if (SWIG_arg_fail(1)) SWIG_fail;
12502 {
12503 PyThreadState* __tstate = wxPyBeginAllowThreads();
12504 result = (int)(arg1)->GetRudderMax();
12505
12506 wxPyEndAllowThreads(__tstate);
12507 if (PyErr_Occurred()) SWIG_fail;
12508 }
12509 {
12510 resultobj = SWIG_From_int((int)(result));
12511 }
12512 return resultobj;
12513 fail:
12514 return NULL;
12515 }
12516
12517
12518 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12519 PyObject *resultobj;
12520 wxJoystick *arg1 = (wxJoystick *) 0 ;
12521 int result;
12522 PyObject * obj0 = 0 ;
12523 char *kwnames[] = {
12524 (char *) "self", NULL
12525 };
12526
12527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12529 if (SWIG_arg_fail(1)) SWIG_fail;
12530 {
12531 PyThreadState* __tstate = wxPyBeginAllowThreads();
12532 result = (int)(arg1)->GetUMin();
12533
12534 wxPyEndAllowThreads(__tstate);
12535 if (PyErr_Occurred()) SWIG_fail;
12536 }
12537 {
12538 resultobj = SWIG_From_int((int)(result));
12539 }
12540 return resultobj;
12541 fail:
12542 return NULL;
12543 }
12544
12545
12546 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12547 PyObject *resultobj;
12548 wxJoystick *arg1 = (wxJoystick *) 0 ;
12549 int result;
12550 PyObject * obj0 = 0 ;
12551 char *kwnames[] = {
12552 (char *) "self", NULL
12553 };
12554
12555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12557 if (SWIG_arg_fail(1)) SWIG_fail;
12558 {
12559 PyThreadState* __tstate = wxPyBeginAllowThreads();
12560 result = (int)(arg1)->GetUMax();
12561
12562 wxPyEndAllowThreads(__tstate);
12563 if (PyErr_Occurred()) SWIG_fail;
12564 }
12565 {
12566 resultobj = SWIG_From_int((int)(result));
12567 }
12568 return resultobj;
12569 fail:
12570 return NULL;
12571 }
12572
12573
12574 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12575 PyObject *resultobj;
12576 wxJoystick *arg1 = (wxJoystick *) 0 ;
12577 int result;
12578 PyObject * obj0 = 0 ;
12579 char *kwnames[] = {
12580 (char *) "self", NULL
12581 };
12582
12583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12585 if (SWIG_arg_fail(1)) SWIG_fail;
12586 {
12587 PyThreadState* __tstate = wxPyBeginAllowThreads();
12588 result = (int)(arg1)->GetVMin();
12589
12590 wxPyEndAllowThreads(__tstate);
12591 if (PyErr_Occurred()) SWIG_fail;
12592 }
12593 {
12594 resultobj = SWIG_From_int((int)(result));
12595 }
12596 return resultobj;
12597 fail:
12598 return NULL;
12599 }
12600
12601
12602 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12603 PyObject *resultobj;
12604 wxJoystick *arg1 = (wxJoystick *) 0 ;
12605 int result;
12606 PyObject * obj0 = 0 ;
12607 char *kwnames[] = {
12608 (char *) "self", NULL
12609 };
12610
12611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12613 if (SWIG_arg_fail(1)) SWIG_fail;
12614 {
12615 PyThreadState* __tstate = wxPyBeginAllowThreads();
12616 result = (int)(arg1)->GetVMax();
12617
12618 wxPyEndAllowThreads(__tstate);
12619 if (PyErr_Occurred()) SWIG_fail;
12620 }
12621 {
12622 resultobj = SWIG_From_int((int)(result));
12623 }
12624 return resultobj;
12625 fail:
12626 return NULL;
12627 }
12628
12629
12630 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12631 PyObject *resultobj;
12632 wxJoystick *arg1 = (wxJoystick *) 0 ;
12633 bool result;
12634 PyObject * obj0 = 0 ;
12635 char *kwnames[] = {
12636 (char *) "self", NULL
12637 };
12638
12639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12641 if (SWIG_arg_fail(1)) SWIG_fail;
12642 {
12643 PyThreadState* __tstate = wxPyBeginAllowThreads();
12644 result = (bool)(arg1)->HasRudder();
12645
12646 wxPyEndAllowThreads(__tstate);
12647 if (PyErr_Occurred()) SWIG_fail;
12648 }
12649 {
12650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12651 }
12652 return resultobj;
12653 fail:
12654 return NULL;
12655 }
12656
12657
12658 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12659 PyObject *resultobj;
12660 wxJoystick *arg1 = (wxJoystick *) 0 ;
12661 bool result;
12662 PyObject * obj0 = 0 ;
12663 char *kwnames[] = {
12664 (char *) "self", NULL
12665 };
12666
12667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12669 if (SWIG_arg_fail(1)) SWIG_fail;
12670 {
12671 PyThreadState* __tstate = wxPyBeginAllowThreads();
12672 result = (bool)(arg1)->HasZ();
12673
12674 wxPyEndAllowThreads(__tstate);
12675 if (PyErr_Occurred()) SWIG_fail;
12676 }
12677 {
12678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12679 }
12680 return resultobj;
12681 fail:
12682 return NULL;
12683 }
12684
12685
12686 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12687 PyObject *resultobj;
12688 wxJoystick *arg1 = (wxJoystick *) 0 ;
12689 bool result;
12690 PyObject * obj0 = 0 ;
12691 char *kwnames[] = {
12692 (char *) "self", NULL
12693 };
12694
12695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12697 if (SWIG_arg_fail(1)) SWIG_fail;
12698 {
12699 PyThreadState* __tstate = wxPyBeginAllowThreads();
12700 result = (bool)(arg1)->HasU();
12701
12702 wxPyEndAllowThreads(__tstate);
12703 if (PyErr_Occurred()) SWIG_fail;
12704 }
12705 {
12706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12707 }
12708 return resultobj;
12709 fail:
12710 return NULL;
12711 }
12712
12713
12714 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12715 PyObject *resultobj;
12716 wxJoystick *arg1 = (wxJoystick *) 0 ;
12717 bool result;
12718 PyObject * obj0 = 0 ;
12719 char *kwnames[] = {
12720 (char *) "self", NULL
12721 };
12722
12723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12725 if (SWIG_arg_fail(1)) SWIG_fail;
12726 {
12727 PyThreadState* __tstate = wxPyBeginAllowThreads();
12728 result = (bool)(arg1)->HasV();
12729
12730 wxPyEndAllowThreads(__tstate);
12731 if (PyErr_Occurred()) SWIG_fail;
12732 }
12733 {
12734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12735 }
12736 return resultobj;
12737 fail:
12738 return NULL;
12739 }
12740
12741
12742 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12743 PyObject *resultobj;
12744 wxJoystick *arg1 = (wxJoystick *) 0 ;
12745 bool result;
12746 PyObject * obj0 = 0 ;
12747 char *kwnames[] = {
12748 (char *) "self", NULL
12749 };
12750
12751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12753 if (SWIG_arg_fail(1)) SWIG_fail;
12754 {
12755 PyThreadState* __tstate = wxPyBeginAllowThreads();
12756 result = (bool)(arg1)->HasPOV();
12757
12758 wxPyEndAllowThreads(__tstate);
12759 if (PyErr_Occurred()) SWIG_fail;
12760 }
12761 {
12762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12763 }
12764 return resultobj;
12765 fail:
12766 return NULL;
12767 }
12768
12769
12770 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12771 PyObject *resultobj;
12772 wxJoystick *arg1 = (wxJoystick *) 0 ;
12773 bool result;
12774 PyObject * obj0 = 0 ;
12775 char *kwnames[] = {
12776 (char *) "self", NULL
12777 };
12778
12779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12781 if (SWIG_arg_fail(1)) SWIG_fail;
12782 {
12783 PyThreadState* __tstate = wxPyBeginAllowThreads();
12784 result = (bool)(arg1)->HasPOV4Dir();
12785
12786 wxPyEndAllowThreads(__tstate);
12787 if (PyErr_Occurred()) SWIG_fail;
12788 }
12789 {
12790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12791 }
12792 return resultobj;
12793 fail:
12794 return NULL;
12795 }
12796
12797
12798 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12799 PyObject *resultobj;
12800 wxJoystick *arg1 = (wxJoystick *) 0 ;
12801 bool result;
12802 PyObject * obj0 = 0 ;
12803 char *kwnames[] = {
12804 (char *) "self", NULL
12805 };
12806
12807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12809 if (SWIG_arg_fail(1)) SWIG_fail;
12810 {
12811 PyThreadState* __tstate = wxPyBeginAllowThreads();
12812 result = (bool)(arg1)->HasPOVCTS();
12813
12814 wxPyEndAllowThreads(__tstate);
12815 if (PyErr_Occurred()) SWIG_fail;
12816 }
12817 {
12818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12819 }
12820 return resultobj;
12821 fail:
12822 return NULL;
12823 }
12824
12825
12826 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12827 PyObject *resultobj;
12828 wxJoystick *arg1 = (wxJoystick *) 0 ;
12829 wxWindow *arg2 = (wxWindow *) 0 ;
12830 int arg3 = (int) 0 ;
12831 bool result;
12832 PyObject * obj0 = 0 ;
12833 PyObject * obj1 = 0 ;
12834 PyObject * obj2 = 0 ;
12835 char *kwnames[] = {
12836 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12837 };
12838
12839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12841 if (SWIG_arg_fail(1)) SWIG_fail;
12842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12843 if (SWIG_arg_fail(2)) SWIG_fail;
12844 if (obj2) {
12845 {
12846 arg3 = (int)(SWIG_As_int(obj2));
12847 if (SWIG_arg_fail(3)) SWIG_fail;
12848 }
12849 }
12850 {
12851 PyThreadState* __tstate = wxPyBeginAllowThreads();
12852 result = (bool)(arg1)->SetCapture(arg2,arg3);
12853
12854 wxPyEndAllowThreads(__tstate);
12855 if (PyErr_Occurred()) SWIG_fail;
12856 }
12857 {
12858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12859 }
12860 return resultobj;
12861 fail:
12862 return NULL;
12863 }
12864
12865
12866 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12867 PyObject *resultobj;
12868 wxJoystick *arg1 = (wxJoystick *) 0 ;
12869 bool result;
12870 PyObject * obj0 = 0 ;
12871 char *kwnames[] = {
12872 (char *) "self", NULL
12873 };
12874
12875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12877 if (SWIG_arg_fail(1)) SWIG_fail;
12878 {
12879 PyThreadState* __tstate = wxPyBeginAllowThreads();
12880 result = (bool)(arg1)->ReleaseCapture();
12881
12882 wxPyEndAllowThreads(__tstate);
12883 if (PyErr_Occurred()) SWIG_fail;
12884 }
12885 {
12886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12887 }
12888 return resultobj;
12889 fail:
12890 return NULL;
12891 }
12892
12893
12894 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12895 PyObject *obj;
12896 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12897 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12898 Py_INCREF(obj);
12899 return Py_BuildValue((char *)"");
12900 }
12901 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12902 PyObject *resultobj;
12903 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12904 int arg2 = (int) 0 ;
12905 int arg3 = (int) wxJOYSTICK1 ;
12906 int arg4 = (int) 0 ;
12907 wxJoystickEvent *result;
12908 PyObject * obj0 = 0 ;
12909 PyObject * obj1 = 0 ;
12910 PyObject * obj2 = 0 ;
12911 PyObject * obj3 = 0 ;
12912 char *kwnames[] = {
12913 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12914 };
12915
12916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12917 if (obj0) {
12918 {
12919 arg1 = (wxEventType)(SWIG_As_int(obj0));
12920 if (SWIG_arg_fail(1)) SWIG_fail;
12921 }
12922 }
12923 if (obj1) {
12924 {
12925 arg2 = (int)(SWIG_As_int(obj1));
12926 if (SWIG_arg_fail(2)) SWIG_fail;
12927 }
12928 }
12929 if (obj2) {
12930 {
12931 arg3 = (int)(SWIG_As_int(obj2));
12932 if (SWIG_arg_fail(3)) SWIG_fail;
12933 }
12934 }
12935 if (obj3) {
12936 {
12937 arg4 = (int)(SWIG_As_int(obj3));
12938 if (SWIG_arg_fail(4)) SWIG_fail;
12939 }
12940 }
12941 {
12942 PyThreadState* __tstate = wxPyBeginAllowThreads();
12943 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12944
12945 wxPyEndAllowThreads(__tstate);
12946 if (PyErr_Occurred()) SWIG_fail;
12947 }
12948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12949 return resultobj;
12950 fail:
12951 return NULL;
12952 }
12953
12954
12955 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12956 PyObject *resultobj;
12957 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12958 wxPoint result;
12959 PyObject * obj0 = 0 ;
12960 char *kwnames[] = {
12961 (char *) "self", NULL
12962 };
12963
12964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12966 if (SWIG_arg_fail(1)) SWIG_fail;
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12970
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 {
12975 wxPoint * resultptr;
12976 resultptr = new wxPoint((wxPoint &)(result));
12977 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12978 }
12979 return resultobj;
12980 fail:
12981 return NULL;
12982 }
12983
12984
12985 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12986 PyObject *resultobj;
12987 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12988 int result;
12989 PyObject * obj0 = 0 ;
12990 char *kwnames[] = {
12991 (char *) "self", NULL
12992 };
12993
12994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12996 if (SWIG_arg_fail(1)) SWIG_fail;
12997 {
12998 PyThreadState* __tstate = wxPyBeginAllowThreads();
12999 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
13000
13001 wxPyEndAllowThreads(__tstate);
13002 if (PyErr_Occurred()) SWIG_fail;
13003 }
13004 {
13005 resultobj = SWIG_From_int((int)(result));
13006 }
13007 return resultobj;
13008 fail:
13009 return NULL;
13010 }
13011
13012
13013 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13014 PyObject *resultobj;
13015 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13016 int result;
13017 PyObject * obj0 = 0 ;
13018 char *kwnames[] = {
13019 (char *) "self", NULL
13020 };
13021
13022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13024 if (SWIG_arg_fail(1)) SWIG_fail;
13025 {
13026 PyThreadState* __tstate = wxPyBeginAllowThreads();
13027 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13028
13029 wxPyEndAllowThreads(__tstate);
13030 if (PyErr_Occurred()) SWIG_fail;
13031 }
13032 {
13033 resultobj = SWIG_From_int((int)(result));
13034 }
13035 return resultobj;
13036 fail:
13037 return NULL;
13038 }
13039
13040
13041 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13042 PyObject *resultobj;
13043 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13044 int result;
13045 PyObject * obj0 = 0 ;
13046 char *kwnames[] = {
13047 (char *) "self", NULL
13048 };
13049
13050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13052 if (SWIG_arg_fail(1)) SWIG_fail;
13053 {
13054 PyThreadState* __tstate = wxPyBeginAllowThreads();
13055 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13056
13057 wxPyEndAllowThreads(__tstate);
13058 if (PyErr_Occurred()) SWIG_fail;
13059 }
13060 {
13061 resultobj = SWIG_From_int((int)(result));
13062 }
13063 return resultobj;
13064 fail:
13065 return NULL;
13066 }
13067
13068
13069 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13070 PyObject *resultobj;
13071 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13072 int result;
13073 PyObject * obj0 = 0 ;
13074 char *kwnames[] = {
13075 (char *) "self", NULL
13076 };
13077
13078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13080 if (SWIG_arg_fail(1)) SWIG_fail;
13081 {
13082 PyThreadState* __tstate = wxPyBeginAllowThreads();
13083 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13084
13085 wxPyEndAllowThreads(__tstate);
13086 if (PyErr_Occurred()) SWIG_fail;
13087 }
13088 {
13089 resultobj = SWIG_From_int((int)(result));
13090 }
13091 return resultobj;
13092 fail:
13093 return NULL;
13094 }
13095
13096
13097 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13098 PyObject *resultobj;
13099 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13100 int arg2 ;
13101 PyObject * obj0 = 0 ;
13102 PyObject * obj1 = 0 ;
13103 char *kwnames[] = {
13104 (char *) "self",(char *) "stick", NULL
13105 };
13106
13107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13109 if (SWIG_arg_fail(1)) SWIG_fail;
13110 {
13111 arg2 = (int)(SWIG_As_int(obj1));
13112 if (SWIG_arg_fail(2)) SWIG_fail;
13113 }
13114 {
13115 PyThreadState* __tstate = wxPyBeginAllowThreads();
13116 (arg1)->SetJoystick(arg2);
13117
13118 wxPyEndAllowThreads(__tstate);
13119 if (PyErr_Occurred()) SWIG_fail;
13120 }
13121 Py_INCREF(Py_None); resultobj = Py_None;
13122 return resultobj;
13123 fail:
13124 return NULL;
13125 }
13126
13127
13128 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13129 PyObject *resultobj;
13130 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13131 int arg2 ;
13132 PyObject * obj0 = 0 ;
13133 PyObject * obj1 = 0 ;
13134 char *kwnames[] = {
13135 (char *) "self",(char *) "state", NULL
13136 };
13137
13138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13140 if (SWIG_arg_fail(1)) SWIG_fail;
13141 {
13142 arg2 = (int)(SWIG_As_int(obj1));
13143 if (SWIG_arg_fail(2)) SWIG_fail;
13144 }
13145 {
13146 PyThreadState* __tstate = wxPyBeginAllowThreads();
13147 (arg1)->SetButtonState(arg2);
13148
13149 wxPyEndAllowThreads(__tstate);
13150 if (PyErr_Occurred()) SWIG_fail;
13151 }
13152 Py_INCREF(Py_None); resultobj = Py_None;
13153 return resultobj;
13154 fail:
13155 return NULL;
13156 }
13157
13158
13159 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13160 PyObject *resultobj;
13161 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13162 int arg2 ;
13163 PyObject * obj0 = 0 ;
13164 PyObject * obj1 = 0 ;
13165 char *kwnames[] = {
13166 (char *) "self",(char *) "change", NULL
13167 };
13168
13169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13171 if (SWIG_arg_fail(1)) SWIG_fail;
13172 {
13173 arg2 = (int)(SWIG_As_int(obj1));
13174 if (SWIG_arg_fail(2)) SWIG_fail;
13175 }
13176 {
13177 PyThreadState* __tstate = wxPyBeginAllowThreads();
13178 (arg1)->SetButtonChange(arg2);
13179
13180 wxPyEndAllowThreads(__tstate);
13181 if (PyErr_Occurred()) SWIG_fail;
13182 }
13183 Py_INCREF(Py_None); resultobj = Py_None;
13184 return resultobj;
13185 fail:
13186 return NULL;
13187 }
13188
13189
13190 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13191 PyObject *resultobj;
13192 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13193 wxPoint *arg2 = 0 ;
13194 wxPoint temp2 ;
13195 PyObject * obj0 = 0 ;
13196 PyObject * obj1 = 0 ;
13197 char *kwnames[] = {
13198 (char *) "self",(char *) "pos", NULL
13199 };
13200
13201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13203 if (SWIG_arg_fail(1)) SWIG_fail;
13204 {
13205 arg2 = &temp2;
13206 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13207 }
13208 {
13209 PyThreadState* __tstate = wxPyBeginAllowThreads();
13210 (arg1)->SetPosition((wxPoint const &)*arg2);
13211
13212 wxPyEndAllowThreads(__tstate);
13213 if (PyErr_Occurred()) SWIG_fail;
13214 }
13215 Py_INCREF(Py_None); resultobj = Py_None;
13216 return resultobj;
13217 fail:
13218 return NULL;
13219 }
13220
13221
13222 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13223 PyObject *resultobj;
13224 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13225 int arg2 ;
13226 PyObject * obj0 = 0 ;
13227 PyObject * obj1 = 0 ;
13228 char *kwnames[] = {
13229 (char *) "self",(char *) "zPos", NULL
13230 };
13231
13232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13234 if (SWIG_arg_fail(1)) SWIG_fail;
13235 {
13236 arg2 = (int)(SWIG_As_int(obj1));
13237 if (SWIG_arg_fail(2)) SWIG_fail;
13238 }
13239 {
13240 PyThreadState* __tstate = wxPyBeginAllowThreads();
13241 (arg1)->SetZPosition(arg2);
13242
13243 wxPyEndAllowThreads(__tstate);
13244 if (PyErr_Occurred()) SWIG_fail;
13245 }
13246 Py_INCREF(Py_None); resultobj = Py_None;
13247 return resultobj;
13248 fail:
13249 return NULL;
13250 }
13251
13252
13253 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13254 PyObject *resultobj;
13255 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13256 bool result;
13257 PyObject * obj0 = 0 ;
13258 char *kwnames[] = {
13259 (char *) "self", NULL
13260 };
13261
13262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13264 if (SWIG_arg_fail(1)) SWIG_fail;
13265 {
13266 PyThreadState* __tstate = wxPyBeginAllowThreads();
13267 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13268
13269 wxPyEndAllowThreads(__tstate);
13270 if (PyErr_Occurred()) SWIG_fail;
13271 }
13272 {
13273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13274 }
13275 return resultobj;
13276 fail:
13277 return NULL;
13278 }
13279
13280
13281 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13282 PyObject *resultobj;
13283 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13284 bool result;
13285 PyObject * obj0 = 0 ;
13286 char *kwnames[] = {
13287 (char *) "self", NULL
13288 };
13289
13290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13292 if (SWIG_arg_fail(1)) SWIG_fail;
13293 {
13294 PyThreadState* __tstate = wxPyBeginAllowThreads();
13295 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13296
13297 wxPyEndAllowThreads(__tstate);
13298 if (PyErr_Occurred()) SWIG_fail;
13299 }
13300 {
13301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13302 }
13303 return resultobj;
13304 fail:
13305 return NULL;
13306 }
13307
13308
13309 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13310 PyObject *resultobj;
13311 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13312 bool result;
13313 PyObject * obj0 = 0 ;
13314 char *kwnames[] = {
13315 (char *) "self", NULL
13316 };
13317
13318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13320 if (SWIG_arg_fail(1)) SWIG_fail;
13321 {
13322 PyThreadState* __tstate = wxPyBeginAllowThreads();
13323 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13324
13325 wxPyEndAllowThreads(__tstate);
13326 if (PyErr_Occurred()) SWIG_fail;
13327 }
13328 {
13329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13330 }
13331 return resultobj;
13332 fail:
13333 return NULL;
13334 }
13335
13336
13337 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13338 PyObject *resultobj;
13339 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13340 int arg2 = (int) wxJOY_BUTTON_ANY ;
13341 bool result;
13342 PyObject * obj0 = 0 ;
13343 PyObject * obj1 = 0 ;
13344 char *kwnames[] = {
13345 (char *) "self",(char *) "but", NULL
13346 };
13347
13348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13350 if (SWIG_arg_fail(1)) SWIG_fail;
13351 if (obj1) {
13352 {
13353 arg2 = (int)(SWIG_As_int(obj1));
13354 if (SWIG_arg_fail(2)) SWIG_fail;
13355 }
13356 }
13357 {
13358 PyThreadState* __tstate = wxPyBeginAllowThreads();
13359 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13360
13361 wxPyEndAllowThreads(__tstate);
13362 if (PyErr_Occurred()) SWIG_fail;
13363 }
13364 {
13365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13366 }
13367 return resultobj;
13368 fail:
13369 return NULL;
13370 }
13371
13372
13373 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13374 PyObject *resultobj;
13375 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13376 int arg2 = (int) wxJOY_BUTTON_ANY ;
13377 bool result;
13378 PyObject * obj0 = 0 ;
13379 PyObject * obj1 = 0 ;
13380 char *kwnames[] = {
13381 (char *) "self",(char *) "but", NULL
13382 };
13383
13384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13386 if (SWIG_arg_fail(1)) SWIG_fail;
13387 if (obj1) {
13388 {
13389 arg2 = (int)(SWIG_As_int(obj1));
13390 if (SWIG_arg_fail(2)) SWIG_fail;
13391 }
13392 }
13393 {
13394 PyThreadState* __tstate = wxPyBeginAllowThreads();
13395 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13396
13397 wxPyEndAllowThreads(__tstate);
13398 if (PyErr_Occurred()) SWIG_fail;
13399 }
13400 {
13401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13402 }
13403 return resultobj;
13404 fail:
13405 return NULL;
13406 }
13407
13408
13409 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13410 PyObject *resultobj;
13411 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13412 int arg2 = (int) wxJOY_BUTTON_ANY ;
13413 bool result;
13414 PyObject * obj0 = 0 ;
13415 PyObject * obj1 = 0 ;
13416 char *kwnames[] = {
13417 (char *) "self",(char *) "but", NULL
13418 };
13419
13420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13422 if (SWIG_arg_fail(1)) SWIG_fail;
13423 if (obj1) {
13424 {
13425 arg2 = (int)(SWIG_As_int(obj1));
13426 if (SWIG_arg_fail(2)) SWIG_fail;
13427 }
13428 }
13429 {
13430 PyThreadState* __tstate = wxPyBeginAllowThreads();
13431 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13432
13433 wxPyEndAllowThreads(__tstate);
13434 if (PyErr_Occurred()) SWIG_fail;
13435 }
13436 {
13437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13438 }
13439 return resultobj;
13440 fail:
13441 return NULL;
13442 }
13443
13444
13445 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13446 PyObject *obj;
13447 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13448 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13449 Py_INCREF(obj);
13450 return Py_BuildValue((char *)"");
13451 }
13452 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13453 PyObject *resultobj;
13454 wxString const &arg1_defvalue = wxPyEmptyString ;
13455 wxString *arg1 = (wxString *) &arg1_defvalue ;
13456 wxSound *result;
13457 bool temp1 = false ;
13458 PyObject * obj0 = 0 ;
13459 char *kwnames[] = {
13460 (char *) "fileName", NULL
13461 };
13462
13463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13464 if (obj0) {
13465 {
13466 arg1 = wxString_in_helper(obj0);
13467 if (arg1 == NULL) SWIG_fail;
13468 temp1 = true;
13469 }
13470 }
13471 {
13472 if (!wxPyCheckForApp()) SWIG_fail;
13473 PyThreadState* __tstate = wxPyBeginAllowThreads();
13474 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13475
13476 wxPyEndAllowThreads(__tstate);
13477 if (PyErr_Occurred()) SWIG_fail;
13478 }
13479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13480 {
13481 if (temp1)
13482 delete arg1;
13483 }
13484 return resultobj;
13485 fail:
13486 {
13487 if (temp1)
13488 delete arg1;
13489 }
13490 return NULL;
13491 }
13492
13493
13494 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13495 PyObject *resultobj;
13496 PyObject *arg1 = (PyObject *) 0 ;
13497 wxSound *result;
13498 PyObject * obj0 = 0 ;
13499 char *kwnames[] = {
13500 (char *) "data", NULL
13501 };
13502
13503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13504 arg1 = obj0;
13505 {
13506 if (!wxPyCheckForApp()) SWIG_fail;
13507 PyThreadState* __tstate = wxPyBeginAllowThreads();
13508 result = (wxSound *)new_wxSound(arg1);
13509
13510 wxPyEndAllowThreads(__tstate);
13511 if (PyErr_Occurred()) SWIG_fail;
13512 }
13513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13514 return resultobj;
13515 fail:
13516 return NULL;
13517 }
13518
13519
13520 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13521 PyObject *resultobj;
13522 wxSound *arg1 = (wxSound *) 0 ;
13523 PyObject * obj0 = 0 ;
13524 char *kwnames[] = {
13525 (char *) "self", NULL
13526 };
13527
13528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13530 if (SWIG_arg_fail(1)) SWIG_fail;
13531 {
13532 PyThreadState* __tstate = wxPyBeginAllowThreads();
13533 delete arg1;
13534
13535 wxPyEndAllowThreads(__tstate);
13536 if (PyErr_Occurred()) SWIG_fail;
13537 }
13538 Py_INCREF(Py_None); resultobj = Py_None;
13539 return resultobj;
13540 fail:
13541 return NULL;
13542 }
13543
13544
13545 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13546 PyObject *resultobj;
13547 wxSound *arg1 = (wxSound *) 0 ;
13548 wxString *arg2 = 0 ;
13549 bool result;
13550 bool temp2 = false ;
13551 PyObject * obj0 = 0 ;
13552 PyObject * obj1 = 0 ;
13553 char *kwnames[] = {
13554 (char *) "self",(char *) "fileName", NULL
13555 };
13556
13557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13559 if (SWIG_arg_fail(1)) SWIG_fail;
13560 {
13561 arg2 = wxString_in_helper(obj1);
13562 if (arg2 == NULL) SWIG_fail;
13563 temp2 = true;
13564 }
13565 {
13566 PyThreadState* __tstate = wxPyBeginAllowThreads();
13567 result = (bool)(arg1)->Create((wxString const &)*arg2);
13568
13569 wxPyEndAllowThreads(__tstate);
13570 if (PyErr_Occurred()) SWIG_fail;
13571 }
13572 {
13573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13574 }
13575 {
13576 if (temp2)
13577 delete arg2;
13578 }
13579 return resultobj;
13580 fail:
13581 {
13582 if (temp2)
13583 delete arg2;
13584 }
13585 return NULL;
13586 }
13587
13588
13589 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13590 PyObject *resultobj;
13591 wxSound *arg1 = (wxSound *) 0 ;
13592 PyObject *arg2 = (PyObject *) 0 ;
13593 bool result;
13594 PyObject * obj0 = 0 ;
13595 PyObject * obj1 = 0 ;
13596 char *kwnames[] = {
13597 (char *) "self",(char *) "data", NULL
13598 };
13599
13600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13602 if (SWIG_arg_fail(1)) SWIG_fail;
13603 arg2 = obj1;
13604 {
13605 PyThreadState* __tstate = wxPyBeginAllowThreads();
13606 result = (bool)wxSound_CreateFromData(arg1,arg2);
13607
13608 wxPyEndAllowThreads(__tstate);
13609 if (PyErr_Occurred()) SWIG_fail;
13610 }
13611 {
13612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13613 }
13614 return resultobj;
13615 fail:
13616 return NULL;
13617 }
13618
13619
13620 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13621 PyObject *resultobj;
13622 wxSound *arg1 = (wxSound *) 0 ;
13623 bool result;
13624 PyObject * obj0 = 0 ;
13625 char *kwnames[] = {
13626 (char *) "self", NULL
13627 };
13628
13629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13631 if (SWIG_arg_fail(1)) SWIG_fail;
13632 {
13633 PyThreadState* __tstate = wxPyBeginAllowThreads();
13634 result = (bool)(arg1)->IsOk();
13635
13636 wxPyEndAllowThreads(__tstate);
13637 if (PyErr_Occurred()) SWIG_fail;
13638 }
13639 {
13640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13641 }
13642 return resultobj;
13643 fail:
13644 return NULL;
13645 }
13646
13647
13648 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13649 PyObject *resultobj;
13650 wxSound *arg1 = (wxSound *) 0 ;
13651 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13652 bool result;
13653 PyObject * obj0 = 0 ;
13654 PyObject * obj1 = 0 ;
13655 char *kwnames[] = {
13656 (char *) "self",(char *) "flags", NULL
13657 };
13658
13659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13661 if (SWIG_arg_fail(1)) SWIG_fail;
13662 if (obj1) {
13663 {
13664 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13665 if (SWIG_arg_fail(2)) SWIG_fail;
13666 }
13667 }
13668 {
13669 if (!wxPyCheckForApp()) SWIG_fail;
13670 PyThreadState* __tstate = wxPyBeginAllowThreads();
13671 result = (bool)((wxSound const *)arg1)->Play(arg2);
13672
13673 wxPyEndAllowThreads(__tstate);
13674 if (PyErr_Occurred()) SWIG_fail;
13675 }
13676 {
13677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13678 }
13679 return resultobj;
13680 fail:
13681 return NULL;
13682 }
13683
13684
13685 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13686 PyObject *resultobj;
13687 wxString *arg1 = 0 ;
13688 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13689 bool result;
13690 bool temp1 = false ;
13691 PyObject * obj0 = 0 ;
13692 PyObject * obj1 = 0 ;
13693 char *kwnames[] = {
13694 (char *) "filename",(char *) "flags", NULL
13695 };
13696
13697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13698 {
13699 arg1 = wxString_in_helper(obj0);
13700 if (arg1 == NULL) SWIG_fail;
13701 temp1 = true;
13702 }
13703 if (obj1) {
13704 {
13705 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13706 if (SWIG_arg_fail(2)) SWIG_fail;
13707 }
13708 }
13709 {
13710 if (!wxPyCheckForApp()) SWIG_fail;
13711 PyThreadState* __tstate = wxPyBeginAllowThreads();
13712 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13713
13714 wxPyEndAllowThreads(__tstate);
13715 if (PyErr_Occurred()) SWIG_fail;
13716 }
13717 {
13718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13719 }
13720 {
13721 if (temp1)
13722 delete arg1;
13723 }
13724 return resultobj;
13725 fail:
13726 {
13727 if (temp1)
13728 delete arg1;
13729 }
13730 return NULL;
13731 }
13732
13733
13734 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13735 PyObject *resultobj;
13736 char *kwnames[] = {
13737 NULL
13738 };
13739
13740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13741 {
13742 if (!wxPyCheckForApp()) SWIG_fail;
13743 PyThreadState* __tstate = wxPyBeginAllowThreads();
13744 wxSound::Stop();
13745
13746 wxPyEndAllowThreads(__tstate);
13747 if (PyErr_Occurred()) SWIG_fail;
13748 }
13749 Py_INCREF(Py_None); resultobj = Py_None;
13750 return resultobj;
13751 fail:
13752 return NULL;
13753 }
13754
13755
13756 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13757 PyObject *obj;
13758 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13759 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13760 Py_INCREF(obj);
13761 return Py_BuildValue((char *)"");
13762 }
13763 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13764 PyObject *resultobj;
13765 wxString *arg1 = 0 ;
13766 wxString *arg2 = 0 ;
13767 wxString *arg3 = 0 ;
13768 wxString *arg4 = 0 ;
13769 wxFileTypeInfo *result;
13770 bool temp1 = false ;
13771 bool temp2 = false ;
13772 bool temp3 = false ;
13773 bool temp4 = false ;
13774 PyObject * obj0 = 0 ;
13775 PyObject * obj1 = 0 ;
13776 PyObject * obj2 = 0 ;
13777 PyObject * obj3 = 0 ;
13778 char *kwnames[] = {
13779 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13780 };
13781
13782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13783 {
13784 arg1 = wxString_in_helper(obj0);
13785 if (arg1 == NULL) SWIG_fail;
13786 temp1 = true;
13787 }
13788 {
13789 arg2 = wxString_in_helper(obj1);
13790 if (arg2 == NULL) SWIG_fail;
13791 temp2 = true;
13792 }
13793 {
13794 arg3 = wxString_in_helper(obj2);
13795 if (arg3 == NULL) SWIG_fail;
13796 temp3 = true;
13797 }
13798 {
13799 arg4 = wxString_in_helper(obj3);
13800 if (arg4 == NULL) SWIG_fail;
13801 temp4 = true;
13802 }
13803 {
13804 PyThreadState* __tstate = wxPyBeginAllowThreads();
13805 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13806
13807 wxPyEndAllowThreads(__tstate);
13808 if (PyErr_Occurred()) SWIG_fail;
13809 }
13810 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13811 {
13812 if (temp1)
13813 delete arg1;
13814 }
13815 {
13816 if (temp2)
13817 delete arg2;
13818 }
13819 {
13820 if (temp3)
13821 delete arg3;
13822 }
13823 {
13824 if (temp4)
13825 delete arg4;
13826 }
13827 return resultobj;
13828 fail:
13829 {
13830 if (temp1)
13831 delete arg1;
13832 }
13833 {
13834 if (temp2)
13835 delete arg2;
13836 }
13837 {
13838 if (temp3)
13839 delete arg3;
13840 }
13841 {
13842 if (temp4)
13843 delete arg4;
13844 }
13845 return NULL;
13846 }
13847
13848
13849 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13850 PyObject *resultobj;
13851 wxArrayString *arg1 = 0 ;
13852 wxFileTypeInfo *result;
13853 bool temp1 = false ;
13854 PyObject * obj0 = 0 ;
13855 char *kwnames[] = {
13856 (char *) "sArray", NULL
13857 };
13858
13859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13860 {
13861 if (! PySequence_Check(obj0)) {
13862 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13863 SWIG_fail;
13864 }
13865 arg1 = new wxArrayString;
13866 temp1 = true;
13867 int i, len=PySequence_Length(obj0);
13868 for (i=0; i<len; i++) {
13869 PyObject* item = PySequence_GetItem(obj0, i);
13870 wxString* s = wxString_in_helper(item);
13871 if (PyErr_Occurred()) SWIG_fail;
13872 arg1->Add(*s);
13873 delete s;
13874 Py_DECREF(item);
13875 }
13876 }
13877 {
13878 PyThreadState* __tstate = wxPyBeginAllowThreads();
13879 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13880
13881 wxPyEndAllowThreads(__tstate);
13882 if (PyErr_Occurred()) SWIG_fail;
13883 }
13884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13885 {
13886 if (temp1) delete arg1;
13887 }
13888 return resultobj;
13889 fail:
13890 {
13891 if (temp1) delete arg1;
13892 }
13893 return NULL;
13894 }
13895
13896
13897 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13898 PyObject *resultobj;
13899 wxFileTypeInfo *result;
13900 char *kwnames[] = {
13901 NULL
13902 };
13903
13904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13905 {
13906 PyThreadState* __tstate = wxPyBeginAllowThreads();
13907 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13908
13909 wxPyEndAllowThreads(__tstate);
13910 if (PyErr_Occurred()) SWIG_fail;
13911 }
13912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13913 return resultobj;
13914 fail:
13915 return NULL;
13916 }
13917
13918
13919 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13920 PyObject *resultobj;
13921 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13922 bool result;
13923 PyObject * obj0 = 0 ;
13924 char *kwnames[] = {
13925 (char *) "self", NULL
13926 };
13927
13928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13930 if (SWIG_arg_fail(1)) SWIG_fail;
13931 {
13932 PyThreadState* __tstate = wxPyBeginAllowThreads();
13933 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13934
13935 wxPyEndAllowThreads(__tstate);
13936 if (PyErr_Occurred()) SWIG_fail;
13937 }
13938 {
13939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13940 }
13941 return resultobj;
13942 fail:
13943 return NULL;
13944 }
13945
13946
13947 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13948 PyObject *resultobj;
13949 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13950 wxString *arg2 = 0 ;
13951 int arg3 = (int) 0 ;
13952 bool temp2 = false ;
13953 PyObject * obj0 = 0 ;
13954 PyObject * obj1 = 0 ;
13955 PyObject * obj2 = 0 ;
13956 char *kwnames[] = {
13957 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13958 };
13959
13960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13962 if (SWIG_arg_fail(1)) SWIG_fail;
13963 {
13964 arg2 = wxString_in_helper(obj1);
13965 if (arg2 == NULL) SWIG_fail;
13966 temp2 = true;
13967 }
13968 if (obj2) {
13969 {
13970 arg3 = (int)(SWIG_As_int(obj2));
13971 if (SWIG_arg_fail(3)) SWIG_fail;
13972 }
13973 }
13974 {
13975 PyThreadState* __tstate = wxPyBeginAllowThreads();
13976 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13977
13978 wxPyEndAllowThreads(__tstate);
13979 if (PyErr_Occurred()) SWIG_fail;
13980 }
13981 Py_INCREF(Py_None); resultobj = Py_None;
13982 {
13983 if (temp2)
13984 delete arg2;
13985 }
13986 return resultobj;
13987 fail:
13988 {
13989 if (temp2)
13990 delete arg2;
13991 }
13992 return NULL;
13993 }
13994
13995
13996 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13997 PyObject *resultobj;
13998 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13999 wxString *arg2 = 0 ;
14000 bool temp2 = false ;
14001 PyObject * obj0 = 0 ;
14002 PyObject * obj1 = 0 ;
14003 char *kwnames[] = {
14004 (char *) "self",(char *) "shortDesc", NULL
14005 };
14006
14007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14009 if (SWIG_arg_fail(1)) SWIG_fail;
14010 {
14011 arg2 = wxString_in_helper(obj1);
14012 if (arg2 == NULL) SWIG_fail;
14013 temp2 = true;
14014 }
14015 {
14016 PyThreadState* __tstate = wxPyBeginAllowThreads();
14017 (arg1)->SetShortDesc((wxString const &)*arg2);
14018
14019 wxPyEndAllowThreads(__tstate);
14020 if (PyErr_Occurred()) SWIG_fail;
14021 }
14022 Py_INCREF(Py_None); resultobj = Py_None;
14023 {
14024 if (temp2)
14025 delete arg2;
14026 }
14027 return resultobj;
14028 fail:
14029 {
14030 if (temp2)
14031 delete arg2;
14032 }
14033 return NULL;
14034 }
14035
14036
14037 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14038 PyObject *resultobj;
14039 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14040 wxString *result;
14041 PyObject * obj0 = 0 ;
14042 char *kwnames[] = {
14043 (char *) "self", NULL
14044 };
14045
14046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14048 if (SWIG_arg_fail(1)) SWIG_fail;
14049 {
14050 PyThreadState* __tstate = wxPyBeginAllowThreads();
14051 {
14052 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14053 result = (wxString *) &_result_ref;
14054 }
14055
14056 wxPyEndAllowThreads(__tstate);
14057 if (PyErr_Occurred()) SWIG_fail;
14058 }
14059 {
14060 #if wxUSE_UNICODE
14061 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14062 #else
14063 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14064 #endif
14065 }
14066 return resultobj;
14067 fail:
14068 return NULL;
14069 }
14070
14071
14072 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14073 PyObject *resultobj;
14074 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14075 wxString *result;
14076 PyObject * obj0 = 0 ;
14077 char *kwnames[] = {
14078 (char *) "self", NULL
14079 };
14080
14081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14083 if (SWIG_arg_fail(1)) SWIG_fail;
14084 {
14085 PyThreadState* __tstate = wxPyBeginAllowThreads();
14086 {
14087 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14088 result = (wxString *) &_result_ref;
14089 }
14090
14091 wxPyEndAllowThreads(__tstate);
14092 if (PyErr_Occurred()) SWIG_fail;
14093 }
14094 {
14095 #if wxUSE_UNICODE
14096 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14097 #else
14098 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14099 #endif
14100 }
14101 return resultobj;
14102 fail:
14103 return NULL;
14104 }
14105
14106
14107 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14108 PyObject *resultobj;
14109 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14110 wxString *result;
14111 PyObject * obj0 = 0 ;
14112 char *kwnames[] = {
14113 (char *) "self", NULL
14114 };
14115
14116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14118 if (SWIG_arg_fail(1)) SWIG_fail;
14119 {
14120 PyThreadState* __tstate = wxPyBeginAllowThreads();
14121 {
14122 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14123 result = (wxString *) &_result_ref;
14124 }
14125
14126 wxPyEndAllowThreads(__tstate);
14127 if (PyErr_Occurred()) SWIG_fail;
14128 }
14129 {
14130 #if wxUSE_UNICODE
14131 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14132 #else
14133 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14134 #endif
14135 }
14136 return resultobj;
14137 fail:
14138 return NULL;
14139 }
14140
14141
14142 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14143 PyObject *resultobj;
14144 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14145 wxString *result;
14146 PyObject * obj0 = 0 ;
14147 char *kwnames[] = {
14148 (char *) "self", NULL
14149 };
14150
14151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14153 if (SWIG_arg_fail(1)) SWIG_fail;
14154 {
14155 PyThreadState* __tstate = wxPyBeginAllowThreads();
14156 {
14157 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14158 result = (wxString *) &_result_ref;
14159 }
14160
14161 wxPyEndAllowThreads(__tstate);
14162 if (PyErr_Occurred()) SWIG_fail;
14163 }
14164 {
14165 #if wxUSE_UNICODE
14166 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14167 #else
14168 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14169 #endif
14170 }
14171 return resultobj;
14172 fail:
14173 return NULL;
14174 }
14175
14176
14177 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14178 PyObject *resultobj;
14179 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14180 wxString *result;
14181 PyObject * obj0 = 0 ;
14182 char *kwnames[] = {
14183 (char *) "self", NULL
14184 };
14185
14186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14188 if (SWIG_arg_fail(1)) SWIG_fail;
14189 {
14190 PyThreadState* __tstate = wxPyBeginAllowThreads();
14191 {
14192 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14193 result = (wxString *) &_result_ref;
14194 }
14195
14196 wxPyEndAllowThreads(__tstate);
14197 if (PyErr_Occurred()) SWIG_fail;
14198 }
14199 {
14200 #if wxUSE_UNICODE
14201 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14202 #else
14203 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14204 #endif
14205 }
14206 return resultobj;
14207 fail:
14208 return NULL;
14209 }
14210
14211
14212 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14213 PyObject *resultobj;
14214 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14215 wxArrayString *result;
14216 PyObject * obj0 = 0 ;
14217 char *kwnames[] = {
14218 (char *) "self", NULL
14219 };
14220
14221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14223 if (SWIG_arg_fail(1)) SWIG_fail;
14224 {
14225 PyThreadState* __tstate = wxPyBeginAllowThreads();
14226 {
14227 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14228 result = (wxArrayString *) &_result_ref;
14229 }
14230
14231 wxPyEndAllowThreads(__tstate);
14232 if (PyErr_Occurred()) SWIG_fail;
14233 }
14234 {
14235 resultobj = wxArrayString2PyList_helper(*result);
14236 }
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj;
14245 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14246 int result;
14247 PyObject * obj0 = 0 ;
14248 char *kwnames[] = {
14249 (char *) "self", NULL
14250 };
14251
14252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14254 if (SWIG_arg_fail(1)) SWIG_fail;
14255 {
14256 PyThreadState* __tstate = wxPyBeginAllowThreads();
14257 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14258
14259 wxPyEndAllowThreads(__tstate);
14260 if (PyErr_Occurred()) SWIG_fail;
14261 }
14262 {
14263 resultobj = SWIG_From_int((int)(result));
14264 }
14265 return resultobj;
14266 fail:
14267 return NULL;
14268 }
14269
14270
14271 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14272 PyObject *resultobj;
14273 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14274 wxString *result;
14275 PyObject * obj0 = 0 ;
14276 char *kwnames[] = {
14277 (char *) "self", NULL
14278 };
14279
14280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14282 if (SWIG_arg_fail(1)) SWIG_fail;
14283 {
14284 PyThreadState* __tstate = wxPyBeginAllowThreads();
14285 {
14286 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14287 result = (wxString *) &_result_ref;
14288 }
14289
14290 wxPyEndAllowThreads(__tstate);
14291 if (PyErr_Occurred()) SWIG_fail;
14292 }
14293 {
14294 #if wxUSE_UNICODE
14295 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14296 #else
14297 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14298 #endif
14299 }
14300 return resultobj;
14301 fail:
14302 return NULL;
14303 }
14304
14305
14306 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14307 PyObject *resultobj;
14308 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14309 int result;
14310 PyObject * obj0 = 0 ;
14311 char *kwnames[] = {
14312 (char *) "self", NULL
14313 };
14314
14315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14317 if (SWIG_arg_fail(1)) SWIG_fail;
14318 {
14319 PyThreadState* __tstate = wxPyBeginAllowThreads();
14320 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14321
14322 wxPyEndAllowThreads(__tstate);
14323 if (PyErr_Occurred()) SWIG_fail;
14324 }
14325 {
14326 resultobj = SWIG_From_int((int)(result));
14327 }
14328 return resultobj;
14329 fail:
14330 return NULL;
14331 }
14332
14333
14334 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14335 PyObject *obj;
14336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14337 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14338 Py_INCREF(obj);
14339 return Py_BuildValue((char *)"");
14340 }
14341 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14342 PyObject *resultobj;
14343 wxFileTypeInfo *arg1 = 0 ;
14344 wxFileType *result;
14345 PyObject * obj0 = 0 ;
14346 char *kwnames[] = {
14347 (char *) "ftInfo", NULL
14348 };
14349
14350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14351 {
14352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14353 if (SWIG_arg_fail(1)) SWIG_fail;
14354 if (arg1 == NULL) {
14355 SWIG_null_ref("wxFileTypeInfo");
14356 }
14357 if (SWIG_arg_fail(1)) SWIG_fail;
14358 }
14359 {
14360 PyThreadState* __tstate = wxPyBeginAllowThreads();
14361 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14362
14363 wxPyEndAllowThreads(__tstate);
14364 if (PyErr_Occurred()) SWIG_fail;
14365 }
14366 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14367 return resultobj;
14368 fail:
14369 return NULL;
14370 }
14371
14372
14373 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14374 PyObject *resultobj;
14375 wxFileType *arg1 = (wxFileType *) 0 ;
14376 PyObject * obj0 = 0 ;
14377 char *kwnames[] = {
14378 (char *) "self", NULL
14379 };
14380
14381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14383 if (SWIG_arg_fail(1)) SWIG_fail;
14384 {
14385 PyThreadState* __tstate = wxPyBeginAllowThreads();
14386 delete arg1;
14387
14388 wxPyEndAllowThreads(__tstate);
14389 if (PyErr_Occurred()) SWIG_fail;
14390 }
14391 Py_INCREF(Py_None); resultobj = Py_None;
14392 return resultobj;
14393 fail:
14394 return NULL;
14395 }
14396
14397
14398 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14399 PyObject *resultobj;
14400 wxFileType *arg1 = (wxFileType *) 0 ;
14401 PyObject *result;
14402 PyObject * obj0 = 0 ;
14403 char *kwnames[] = {
14404 (char *) "self", NULL
14405 };
14406
14407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14409 if (SWIG_arg_fail(1)) SWIG_fail;
14410 {
14411 PyThreadState* __tstate = wxPyBeginAllowThreads();
14412 result = (PyObject *)wxFileType_GetMimeType(arg1);
14413
14414 wxPyEndAllowThreads(__tstate);
14415 if (PyErr_Occurred()) SWIG_fail;
14416 }
14417 resultobj = result;
14418 return resultobj;
14419 fail:
14420 return NULL;
14421 }
14422
14423
14424 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14425 PyObject *resultobj;
14426 wxFileType *arg1 = (wxFileType *) 0 ;
14427 PyObject *result;
14428 PyObject * obj0 = 0 ;
14429 char *kwnames[] = {
14430 (char *) "self", NULL
14431 };
14432
14433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14435 if (SWIG_arg_fail(1)) SWIG_fail;
14436 {
14437 PyThreadState* __tstate = wxPyBeginAllowThreads();
14438 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14439
14440 wxPyEndAllowThreads(__tstate);
14441 if (PyErr_Occurred()) SWIG_fail;
14442 }
14443 resultobj = result;
14444 return resultobj;
14445 fail:
14446 return NULL;
14447 }
14448
14449
14450 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14451 PyObject *resultobj;
14452 wxFileType *arg1 = (wxFileType *) 0 ;
14453 PyObject *result;
14454 PyObject * obj0 = 0 ;
14455 char *kwnames[] = {
14456 (char *) "self", NULL
14457 };
14458
14459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14461 if (SWIG_arg_fail(1)) SWIG_fail;
14462 {
14463 PyThreadState* __tstate = wxPyBeginAllowThreads();
14464 result = (PyObject *)wxFileType_GetExtensions(arg1);
14465
14466 wxPyEndAllowThreads(__tstate);
14467 if (PyErr_Occurred()) SWIG_fail;
14468 }
14469 resultobj = result;
14470 return resultobj;
14471 fail:
14472 return NULL;
14473 }
14474
14475
14476 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14477 PyObject *resultobj;
14478 wxFileType *arg1 = (wxFileType *) 0 ;
14479 wxIcon *result;
14480 PyObject * obj0 = 0 ;
14481 char *kwnames[] = {
14482 (char *) "self", NULL
14483 };
14484
14485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14487 if (SWIG_arg_fail(1)) SWIG_fail;
14488 {
14489 PyThreadState* __tstate = wxPyBeginAllowThreads();
14490 result = (wxIcon *)wxFileType_GetIcon(arg1);
14491
14492 wxPyEndAllowThreads(__tstate);
14493 if (PyErr_Occurred()) SWIG_fail;
14494 }
14495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14496 return resultobj;
14497 fail:
14498 return NULL;
14499 }
14500
14501
14502 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14503 PyObject *resultobj;
14504 wxFileType *arg1 = (wxFileType *) 0 ;
14505 PyObject *result;
14506 PyObject * obj0 = 0 ;
14507 char *kwnames[] = {
14508 (char *) "self", NULL
14509 };
14510
14511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14513 if (SWIG_arg_fail(1)) SWIG_fail;
14514 {
14515 PyThreadState* __tstate = wxPyBeginAllowThreads();
14516 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14517
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 resultobj = result;
14522 return resultobj;
14523 fail:
14524 return NULL;
14525 }
14526
14527
14528 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14529 PyObject *resultobj;
14530 wxFileType *arg1 = (wxFileType *) 0 ;
14531 PyObject *result;
14532 PyObject * obj0 = 0 ;
14533 char *kwnames[] = {
14534 (char *) "self", NULL
14535 };
14536
14537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14539 if (SWIG_arg_fail(1)) SWIG_fail;
14540 {
14541 PyThreadState* __tstate = wxPyBeginAllowThreads();
14542 result = (PyObject *)wxFileType_GetDescription(arg1);
14543
14544 wxPyEndAllowThreads(__tstate);
14545 if (PyErr_Occurred()) SWIG_fail;
14546 }
14547 resultobj = result;
14548 return resultobj;
14549 fail:
14550 return NULL;
14551 }
14552
14553
14554 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14555 PyObject *resultobj;
14556 wxFileType *arg1 = (wxFileType *) 0 ;
14557 wxString *arg2 = 0 ;
14558 wxString const &arg3_defvalue = wxPyEmptyString ;
14559 wxString *arg3 = (wxString *) &arg3_defvalue ;
14560 PyObject *result;
14561 bool temp2 = false ;
14562 bool temp3 = false ;
14563 PyObject * obj0 = 0 ;
14564 PyObject * obj1 = 0 ;
14565 PyObject * obj2 = 0 ;
14566 char *kwnames[] = {
14567 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14568 };
14569
14570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14572 if (SWIG_arg_fail(1)) SWIG_fail;
14573 {
14574 arg2 = wxString_in_helper(obj1);
14575 if (arg2 == NULL) SWIG_fail;
14576 temp2 = true;
14577 }
14578 if (obj2) {
14579 {
14580 arg3 = wxString_in_helper(obj2);
14581 if (arg3 == NULL) SWIG_fail;
14582 temp3 = true;
14583 }
14584 }
14585 {
14586 PyThreadState* __tstate = wxPyBeginAllowThreads();
14587 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14588
14589 wxPyEndAllowThreads(__tstate);
14590 if (PyErr_Occurred()) SWIG_fail;
14591 }
14592 resultobj = result;
14593 {
14594 if (temp2)
14595 delete arg2;
14596 }
14597 {
14598 if (temp3)
14599 delete arg3;
14600 }
14601 return resultobj;
14602 fail:
14603 {
14604 if (temp2)
14605 delete arg2;
14606 }
14607 {
14608 if (temp3)
14609 delete arg3;
14610 }
14611 return NULL;
14612 }
14613
14614
14615 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14616 PyObject *resultobj;
14617 wxFileType *arg1 = (wxFileType *) 0 ;
14618 wxString *arg2 = 0 ;
14619 wxString const &arg3_defvalue = wxPyEmptyString ;
14620 wxString *arg3 = (wxString *) &arg3_defvalue ;
14621 PyObject *result;
14622 bool temp2 = false ;
14623 bool temp3 = false ;
14624 PyObject * obj0 = 0 ;
14625 PyObject * obj1 = 0 ;
14626 PyObject * obj2 = 0 ;
14627 char *kwnames[] = {
14628 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14629 };
14630
14631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14633 if (SWIG_arg_fail(1)) SWIG_fail;
14634 {
14635 arg2 = wxString_in_helper(obj1);
14636 if (arg2 == NULL) SWIG_fail;
14637 temp2 = true;
14638 }
14639 if (obj2) {
14640 {
14641 arg3 = wxString_in_helper(obj2);
14642 if (arg3 == NULL) SWIG_fail;
14643 temp3 = true;
14644 }
14645 }
14646 {
14647 PyThreadState* __tstate = wxPyBeginAllowThreads();
14648 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14649
14650 wxPyEndAllowThreads(__tstate);
14651 if (PyErr_Occurred()) SWIG_fail;
14652 }
14653 resultobj = result;
14654 {
14655 if (temp2)
14656 delete arg2;
14657 }
14658 {
14659 if (temp3)
14660 delete arg3;
14661 }
14662 return resultobj;
14663 fail:
14664 {
14665 if (temp2)
14666 delete arg2;
14667 }
14668 {
14669 if (temp3)
14670 delete arg3;
14671 }
14672 return NULL;
14673 }
14674
14675
14676 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14677 PyObject *resultobj;
14678 wxFileType *arg1 = (wxFileType *) 0 ;
14679 wxString *arg2 = 0 ;
14680 wxString const &arg3_defvalue = wxPyEmptyString ;
14681 wxString *arg3 = (wxString *) &arg3_defvalue ;
14682 PyObject *result;
14683 bool temp2 = false ;
14684 bool temp3 = false ;
14685 PyObject * obj0 = 0 ;
14686 PyObject * obj1 = 0 ;
14687 PyObject * obj2 = 0 ;
14688 char *kwnames[] = {
14689 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14690 };
14691
14692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14694 if (SWIG_arg_fail(1)) SWIG_fail;
14695 {
14696 arg2 = wxString_in_helper(obj1);
14697 if (arg2 == NULL) SWIG_fail;
14698 temp2 = true;
14699 }
14700 if (obj2) {
14701 {
14702 arg3 = wxString_in_helper(obj2);
14703 if (arg3 == NULL) SWIG_fail;
14704 temp3 = true;
14705 }
14706 }
14707 {
14708 PyThreadState* __tstate = wxPyBeginAllowThreads();
14709 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14710
14711 wxPyEndAllowThreads(__tstate);
14712 if (PyErr_Occurred()) SWIG_fail;
14713 }
14714 resultobj = result;
14715 {
14716 if (temp2)
14717 delete arg2;
14718 }
14719 {
14720 if (temp3)
14721 delete arg3;
14722 }
14723 return resultobj;
14724 fail:
14725 {
14726 if (temp2)
14727 delete arg2;
14728 }
14729 {
14730 if (temp3)
14731 delete arg3;
14732 }
14733 return NULL;
14734 }
14735
14736
14737 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14738 PyObject *resultobj;
14739 wxFileType *arg1 = (wxFileType *) 0 ;
14740 wxString *arg2 = 0 ;
14741 wxString *arg3 = 0 ;
14742 bool arg4 = (bool) true ;
14743 bool result;
14744 bool temp2 = false ;
14745 bool temp3 = false ;
14746 PyObject * obj0 = 0 ;
14747 PyObject * obj1 = 0 ;
14748 PyObject * obj2 = 0 ;
14749 PyObject * obj3 = 0 ;
14750 char *kwnames[] = {
14751 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14752 };
14753
14754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14756 if (SWIG_arg_fail(1)) SWIG_fail;
14757 {
14758 arg2 = wxString_in_helper(obj1);
14759 if (arg2 == NULL) SWIG_fail;
14760 temp2 = true;
14761 }
14762 {
14763 arg3 = wxString_in_helper(obj2);
14764 if (arg3 == NULL) SWIG_fail;
14765 temp3 = true;
14766 }
14767 if (obj3) {
14768 {
14769 arg4 = (bool)(SWIG_As_bool(obj3));
14770 if (SWIG_arg_fail(4)) SWIG_fail;
14771 }
14772 }
14773 {
14774 PyThreadState* __tstate = wxPyBeginAllowThreads();
14775 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14776
14777 wxPyEndAllowThreads(__tstate);
14778 if (PyErr_Occurred()) SWIG_fail;
14779 }
14780 {
14781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14782 }
14783 {
14784 if (temp2)
14785 delete arg2;
14786 }
14787 {
14788 if (temp3)
14789 delete arg3;
14790 }
14791 return resultobj;
14792 fail:
14793 {
14794 if (temp2)
14795 delete arg2;
14796 }
14797 {
14798 if (temp3)
14799 delete arg3;
14800 }
14801 return NULL;
14802 }
14803
14804
14805 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14806 PyObject *resultobj;
14807 wxFileType *arg1 = (wxFileType *) 0 ;
14808 wxString const &arg2_defvalue = wxPyEmptyString ;
14809 wxString *arg2 = (wxString *) &arg2_defvalue ;
14810 int arg3 = (int) 0 ;
14811 bool result;
14812 bool temp2 = false ;
14813 PyObject * obj0 = 0 ;
14814 PyObject * obj1 = 0 ;
14815 PyObject * obj2 = 0 ;
14816 char *kwnames[] = {
14817 (char *) "self",(char *) "cmd",(char *) "index", NULL
14818 };
14819
14820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14822 if (SWIG_arg_fail(1)) SWIG_fail;
14823 if (obj1) {
14824 {
14825 arg2 = wxString_in_helper(obj1);
14826 if (arg2 == NULL) SWIG_fail;
14827 temp2 = true;
14828 }
14829 }
14830 if (obj2) {
14831 {
14832 arg3 = (int)(SWIG_As_int(obj2));
14833 if (SWIG_arg_fail(3)) SWIG_fail;
14834 }
14835 }
14836 {
14837 PyThreadState* __tstate = wxPyBeginAllowThreads();
14838 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14839
14840 wxPyEndAllowThreads(__tstate);
14841 if (PyErr_Occurred()) SWIG_fail;
14842 }
14843 {
14844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14845 }
14846 {
14847 if (temp2)
14848 delete arg2;
14849 }
14850 return resultobj;
14851 fail:
14852 {
14853 if (temp2)
14854 delete arg2;
14855 }
14856 return NULL;
14857 }
14858
14859
14860 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14861 PyObject *resultobj;
14862 wxFileType *arg1 = (wxFileType *) 0 ;
14863 bool result;
14864 PyObject * obj0 = 0 ;
14865 char *kwnames[] = {
14866 (char *) "self", NULL
14867 };
14868
14869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14871 if (SWIG_arg_fail(1)) SWIG_fail;
14872 {
14873 PyThreadState* __tstate = wxPyBeginAllowThreads();
14874 result = (bool)(arg1)->Unassociate();
14875
14876 wxPyEndAllowThreads(__tstate);
14877 if (PyErr_Occurred()) SWIG_fail;
14878 }
14879 {
14880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14881 }
14882 return resultobj;
14883 fail:
14884 return NULL;
14885 }
14886
14887
14888 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14889 PyObject *resultobj;
14890 wxString *arg1 = 0 ;
14891 wxString *arg2 = 0 ;
14892 wxString const &arg3_defvalue = wxPyEmptyString ;
14893 wxString *arg3 = (wxString *) &arg3_defvalue ;
14894 wxString result;
14895 bool temp1 = false ;
14896 bool temp2 = false ;
14897 bool temp3 = false ;
14898 PyObject * obj0 = 0 ;
14899 PyObject * obj1 = 0 ;
14900 PyObject * obj2 = 0 ;
14901 char *kwnames[] = {
14902 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14903 };
14904
14905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14906 {
14907 arg1 = wxString_in_helper(obj0);
14908 if (arg1 == NULL) SWIG_fail;
14909 temp1 = true;
14910 }
14911 {
14912 arg2 = wxString_in_helper(obj1);
14913 if (arg2 == NULL) SWIG_fail;
14914 temp2 = true;
14915 }
14916 if (obj2) {
14917 {
14918 arg3 = wxString_in_helper(obj2);
14919 if (arg3 == NULL) SWIG_fail;
14920 temp3 = true;
14921 }
14922 }
14923 {
14924 PyThreadState* __tstate = wxPyBeginAllowThreads();
14925 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14926
14927 wxPyEndAllowThreads(__tstate);
14928 if (PyErr_Occurred()) SWIG_fail;
14929 }
14930 {
14931 #if wxUSE_UNICODE
14932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14933 #else
14934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14935 #endif
14936 }
14937 {
14938 if (temp1)
14939 delete arg1;
14940 }
14941 {
14942 if (temp2)
14943 delete arg2;
14944 }
14945 {
14946 if (temp3)
14947 delete arg3;
14948 }
14949 return resultobj;
14950 fail:
14951 {
14952 if (temp1)
14953 delete arg1;
14954 }
14955 {
14956 if (temp2)
14957 delete arg2;
14958 }
14959 {
14960 if (temp3)
14961 delete arg3;
14962 }
14963 return NULL;
14964 }
14965
14966
14967 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14968 PyObject *obj;
14969 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14970 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14971 Py_INCREF(obj);
14972 return Py_BuildValue((char *)"");
14973 }
14974 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14975 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14976 return 1;
14977 }
14978
14979
14980 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14981 PyObject *pyobj;
14982
14983 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14984 return pyobj;
14985 }
14986
14987
14988 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14989 PyObject *resultobj;
14990 wxString *arg1 = 0 ;
14991 wxString *arg2 = 0 ;
14992 bool result;
14993 bool temp1 = false ;
14994 bool temp2 = false ;
14995 PyObject * obj0 = 0 ;
14996 PyObject * obj1 = 0 ;
14997 char *kwnames[] = {
14998 (char *) "mimeType",(char *) "wildcard", NULL
14999 };
15000
15001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15002 {
15003 arg1 = wxString_in_helper(obj0);
15004 if (arg1 == NULL) SWIG_fail;
15005 temp1 = true;
15006 }
15007 {
15008 arg2 = wxString_in_helper(obj1);
15009 if (arg2 == NULL) SWIG_fail;
15010 temp2 = true;
15011 }
15012 {
15013 PyThreadState* __tstate = wxPyBeginAllowThreads();
15014 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15015
15016 wxPyEndAllowThreads(__tstate);
15017 if (PyErr_Occurred()) SWIG_fail;
15018 }
15019 {
15020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15021 }
15022 {
15023 if (temp1)
15024 delete arg1;
15025 }
15026 {
15027 if (temp2)
15028 delete arg2;
15029 }
15030 return resultobj;
15031 fail:
15032 {
15033 if (temp1)
15034 delete arg1;
15035 }
15036 {
15037 if (temp2)
15038 delete arg2;
15039 }
15040 return NULL;
15041 }
15042
15043
15044 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15045 PyObject *resultobj;
15046 wxMimeTypesManager *result;
15047 char *kwnames[] = {
15048 NULL
15049 };
15050
15051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15052 {
15053 PyThreadState* __tstate = wxPyBeginAllowThreads();
15054 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15055
15056 wxPyEndAllowThreads(__tstate);
15057 if (PyErr_Occurred()) SWIG_fail;
15058 }
15059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15060 return resultobj;
15061 fail:
15062 return NULL;
15063 }
15064
15065
15066 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15067 PyObject *resultobj;
15068 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15069 int arg2 = (int) wxMAILCAP_ALL ;
15070 wxString const &arg3_defvalue = wxPyEmptyString ;
15071 wxString *arg3 = (wxString *) &arg3_defvalue ;
15072 bool temp3 = false ;
15073 PyObject * obj0 = 0 ;
15074 PyObject * obj1 = 0 ;
15075 PyObject * obj2 = 0 ;
15076 char *kwnames[] = {
15077 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15078 };
15079
15080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15082 if (SWIG_arg_fail(1)) SWIG_fail;
15083 if (obj1) {
15084 {
15085 arg2 = (int)(SWIG_As_int(obj1));
15086 if (SWIG_arg_fail(2)) SWIG_fail;
15087 }
15088 }
15089 if (obj2) {
15090 {
15091 arg3 = wxString_in_helper(obj2);
15092 if (arg3 == NULL) SWIG_fail;
15093 temp3 = true;
15094 }
15095 }
15096 {
15097 PyThreadState* __tstate = wxPyBeginAllowThreads();
15098 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15099
15100 wxPyEndAllowThreads(__tstate);
15101 if (PyErr_Occurred()) SWIG_fail;
15102 }
15103 Py_INCREF(Py_None); resultobj = Py_None;
15104 {
15105 if (temp3)
15106 delete arg3;
15107 }
15108 return resultobj;
15109 fail:
15110 {
15111 if (temp3)
15112 delete arg3;
15113 }
15114 return NULL;
15115 }
15116
15117
15118 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15119 PyObject *resultobj;
15120 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15121 PyObject * obj0 = 0 ;
15122 char *kwnames[] = {
15123 (char *) "self", NULL
15124 };
15125
15126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
15131 (arg1)->ClearData();
15132
15133 wxPyEndAllowThreads(__tstate);
15134 if (PyErr_Occurred()) SWIG_fail;
15135 }
15136 Py_INCREF(Py_None); resultobj = Py_None;
15137 return resultobj;
15138 fail:
15139 return NULL;
15140 }
15141
15142
15143 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15144 PyObject *resultobj;
15145 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15146 wxString *arg2 = 0 ;
15147 wxFileType *result;
15148 bool temp2 = false ;
15149 PyObject * obj0 = 0 ;
15150 PyObject * obj1 = 0 ;
15151 char *kwnames[] = {
15152 (char *) "self",(char *) "ext", NULL
15153 };
15154
15155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15157 if (SWIG_arg_fail(1)) SWIG_fail;
15158 {
15159 arg2 = wxString_in_helper(obj1);
15160 if (arg2 == NULL) SWIG_fail;
15161 temp2 = true;
15162 }
15163 {
15164 PyThreadState* __tstate = wxPyBeginAllowThreads();
15165 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15166
15167 wxPyEndAllowThreads(__tstate);
15168 if (PyErr_Occurred()) SWIG_fail;
15169 }
15170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15171 {
15172 if (temp2)
15173 delete arg2;
15174 }
15175 return resultobj;
15176 fail:
15177 {
15178 if (temp2)
15179 delete arg2;
15180 }
15181 return NULL;
15182 }
15183
15184
15185 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15186 PyObject *resultobj;
15187 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15188 wxString *arg2 = 0 ;
15189 wxFileType *result;
15190 bool temp2 = false ;
15191 PyObject * obj0 = 0 ;
15192 PyObject * obj1 = 0 ;
15193 char *kwnames[] = {
15194 (char *) "self",(char *) "mimeType", NULL
15195 };
15196
15197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15199 if (SWIG_arg_fail(1)) SWIG_fail;
15200 {
15201 arg2 = wxString_in_helper(obj1);
15202 if (arg2 == NULL) SWIG_fail;
15203 temp2 = true;
15204 }
15205 {
15206 PyThreadState* __tstate = wxPyBeginAllowThreads();
15207 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15208
15209 wxPyEndAllowThreads(__tstate);
15210 if (PyErr_Occurred()) SWIG_fail;
15211 }
15212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15213 {
15214 if (temp2)
15215 delete arg2;
15216 }
15217 return resultobj;
15218 fail:
15219 {
15220 if (temp2)
15221 delete arg2;
15222 }
15223 return NULL;
15224 }
15225
15226
15227 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15228 PyObject *resultobj;
15229 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15230 wxString *arg2 = 0 ;
15231 bool arg3 = (bool) false ;
15232 bool result;
15233 bool temp2 = false ;
15234 PyObject * obj0 = 0 ;
15235 PyObject * obj1 = 0 ;
15236 PyObject * obj2 = 0 ;
15237 char *kwnames[] = {
15238 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15239 };
15240
15241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15243 if (SWIG_arg_fail(1)) SWIG_fail;
15244 {
15245 arg2 = wxString_in_helper(obj1);
15246 if (arg2 == NULL) SWIG_fail;
15247 temp2 = true;
15248 }
15249 if (obj2) {
15250 {
15251 arg3 = (bool)(SWIG_As_bool(obj2));
15252 if (SWIG_arg_fail(3)) SWIG_fail;
15253 }
15254 }
15255 {
15256 PyThreadState* __tstate = wxPyBeginAllowThreads();
15257 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15258
15259 wxPyEndAllowThreads(__tstate);
15260 if (PyErr_Occurred()) SWIG_fail;
15261 }
15262 {
15263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15264 }
15265 {
15266 if (temp2)
15267 delete arg2;
15268 }
15269 return resultobj;
15270 fail:
15271 {
15272 if (temp2)
15273 delete arg2;
15274 }
15275 return NULL;
15276 }
15277
15278
15279 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15280 PyObject *resultobj;
15281 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15282 wxString *arg2 = 0 ;
15283 bool result;
15284 bool temp2 = false ;
15285 PyObject * obj0 = 0 ;
15286 PyObject * obj1 = 0 ;
15287 char *kwnames[] = {
15288 (char *) "self",(char *) "filename", NULL
15289 };
15290
15291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15293 if (SWIG_arg_fail(1)) SWIG_fail;
15294 {
15295 arg2 = wxString_in_helper(obj1);
15296 if (arg2 == NULL) SWIG_fail;
15297 temp2 = true;
15298 }
15299 {
15300 PyThreadState* __tstate = wxPyBeginAllowThreads();
15301 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15302
15303 wxPyEndAllowThreads(__tstate);
15304 if (PyErr_Occurred()) SWIG_fail;
15305 }
15306 {
15307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15308 }
15309 {
15310 if (temp2)
15311 delete arg2;
15312 }
15313 return resultobj;
15314 fail:
15315 {
15316 if (temp2)
15317 delete arg2;
15318 }
15319 return NULL;
15320 }
15321
15322
15323 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15324 PyObject *resultobj;
15325 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15326 PyObject *result;
15327 PyObject * obj0 = 0 ;
15328 char *kwnames[] = {
15329 (char *) "self", NULL
15330 };
15331
15332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15334 if (SWIG_arg_fail(1)) SWIG_fail;
15335 {
15336 PyThreadState* __tstate = wxPyBeginAllowThreads();
15337 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15338
15339 wxPyEndAllowThreads(__tstate);
15340 if (PyErr_Occurred()) SWIG_fail;
15341 }
15342 resultobj = result;
15343 return resultobj;
15344 fail:
15345 return NULL;
15346 }
15347
15348
15349 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15350 PyObject *resultobj;
15351 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15352 wxFileTypeInfo *arg2 = 0 ;
15353 PyObject * obj0 = 0 ;
15354 PyObject * obj1 = 0 ;
15355 char *kwnames[] = {
15356 (char *) "self",(char *) "ft", NULL
15357 };
15358
15359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15361 if (SWIG_arg_fail(1)) SWIG_fail;
15362 {
15363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15364 if (SWIG_arg_fail(2)) SWIG_fail;
15365 if (arg2 == NULL) {
15366 SWIG_null_ref("wxFileTypeInfo");
15367 }
15368 if (SWIG_arg_fail(2)) SWIG_fail;
15369 }
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15373
15374 wxPyEndAllowThreads(__tstate);
15375 if (PyErr_Occurred()) SWIG_fail;
15376 }
15377 Py_INCREF(Py_None); resultobj = Py_None;
15378 return resultobj;
15379 fail:
15380 return NULL;
15381 }
15382
15383
15384 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15385 PyObject *resultobj;
15386 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15387 wxFileTypeInfo *arg2 = 0 ;
15388 wxFileType *result;
15389 PyObject * obj0 = 0 ;
15390 PyObject * obj1 = 0 ;
15391 char *kwnames[] = {
15392 (char *) "self",(char *) "ftInfo", NULL
15393 };
15394
15395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15397 if (SWIG_arg_fail(1)) SWIG_fail;
15398 {
15399 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15400 if (SWIG_arg_fail(2)) SWIG_fail;
15401 if (arg2 == NULL) {
15402 SWIG_null_ref("wxFileTypeInfo");
15403 }
15404 if (SWIG_arg_fail(2)) SWIG_fail;
15405 }
15406 {
15407 PyThreadState* __tstate = wxPyBeginAllowThreads();
15408 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15409
15410 wxPyEndAllowThreads(__tstate);
15411 if (PyErr_Occurred()) SWIG_fail;
15412 }
15413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15414 return resultobj;
15415 fail:
15416 return NULL;
15417 }
15418
15419
15420 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15421 PyObject *resultobj;
15422 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15423 wxFileType *arg2 = (wxFileType *) 0 ;
15424 bool result;
15425 PyObject * obj0 = 0 ;
15426 PyObject * obj1 = 0 ;
15427 char *kwnames[] = {
15428 (char *) "self",(char *) "ft", NULL
15429 };
15430
15431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15433 if (SWIG_arg_fail(1)) SWIG_fail;
15434 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15435 if (SWIG_arg_fail(2)) SWIG_fail;
15436 {
15437 PyThreadState* __tstate = wxPyBeginAllowThreads();
15438 result = (bool)(arg1)->Unassociate(arg2);
15439
15440 wxPyEndAllowThreads(__tstate);
15441 if (PyErr_Occurred()) SWIG_fail;
15442 }
15443 {
15444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15445 }
15446 return resultobj;
15447 fail:
15448 return NULL;
15449 }
15450
15451
15452 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15453 PyObject *resultobj;
15454 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15455 PyObject * obj0 = 0 ;
15456 char *kwnames[] = {
15457 (char *) "self", NULL
15458 };
15459
15460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15462 if (SWIG_arg_fail(1)) SWIG_fail;
15463 {
15464 PyThreadState* __tstate = wxPyBeginAllowThreads();
15465 delete arg1;
15466
15467 wxPyEndAllowThreads(__tstate);
15468 if (PyErr_Occurred()) SWIG_fail;
15469 }
15470 Py_INCREF(Py_None); resultobj = Py_None;
15471 return resultobj;
15472 fail:
15473 return NULL;
15474 }
15475
15476
15477 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15478 PyObject *obj;
15479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15480 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15481 Py_INCREF(obj);
15482 return Py_BuildValue((char *)"");
15483 }
15484 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15485 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15486 return 1;
15487 }
15488
15489
15490 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15491 PyObject *pyobj;
15492
15493 {
15494 #if wxUSE_UNICODE
15495 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15496 #else
15497 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15498 #endif
15499 }
15500 return pyobj;
15501 }
15502
15503
15504 static int _wrap_ART_MENU_set(PyObject *) {
15505 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15506 return 1;
15507 }
15508
15509
15510 static PyObject *_wrap_ART_MENU_get(void) {
15511 PyObject *pyobj;
15512
15513 {
15514 #if wxUSE_UNICODE
15515 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15516 #else
15517 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15518 #endif
15519 }
15520 return pyobj;
15521 }
15522
15523
15524 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15525 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15526 return 1;
15527 }
15528
15529
15530 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15531 PyObject *pyobj;
15532
15533 {
15534 #if wxUSE_UNICODE
15535 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15536 #else
15537 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15538 #endif
15539 }
15540 return pyobj;
15541 }
15542
15543
15544 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15545 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15546 return 1;
15547 }
15548
15549
15550 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15551 PyObject *pyobj;
15552
15553 {
15554 #if wxUSE_UNICODE
15555 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15556 #else
15557 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15558 #endif
15559 }
15560 return pyobj;
15561 }
15562
15563
15564 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15565 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15566 return 1;
15567 }
15568
15569
15570 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15571 PyObject *pyobj;
15572
15573 {
15574 #if wxUSE_UNICODE
15575 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15576 #else
15577 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15578 #endif
15579 }
15580 return pyobj;
15581 }
15582
15583
15584 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15585 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15586 return 1;
15587 }
15588
15589
15590 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15591 PyObject *pyobj;
15592
15593 {
15594 #if wxUSE_UNICODE
15595 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15596 #else
15597 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15598 #endif
15599 }
15600 return pyobj;
15601 }
15602
15603
15604 static int _wrap_ART_BUTTON_set(PyObject *) {
15605 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15606 return 1;
15607 }
15608
15609
15610 static PyObject *_wrap_ART_BUTTON_get(void) {
15611 PyObject *pyobj;
15612
15613 {
15614 #if wxUSE_UNICODE
15615 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15616 #else
15617 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15618 #endif
15619 }
15620 return pyobj;
15621 }
15622
15623
15624 static int _wrap_ART_OTHER_set(PyObject *) {
15625 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15626 return 1;
15627 }
15628
15629
15630 static PyObject *_wrap_ART_OTHER_get(void) {
15631 PyObject *pyobj;
15632
15633 {
15634 #if wxUSE_UNICODE
15635 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15636 #else
15637 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15638 #endif
15639 }
15640 return pyobj;
15641 }
15642
15643
15644 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15645 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15646 return 1;
15647 }
15648
15649
15650 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15651 PyObject *pyobj;
15652
15653 {
15654 #if wxUSE_UNICODE
15655 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15656 #else
15657 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15658 #endif
15659 }
15660 return pyobj;
15661 }
15662
15663
15664 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15665 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15666 return 1;
15667 }
15668
15669
15670 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15671 PyObject *pyobj;
15672
15673 {
15674 #if wxUSE_UNICODE
15675 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15676 #else
15677 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15678 #endif
15679 }
15680 return pyobj;
15681 }
15682
15683
15684 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15685 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15686 return 1;
15687 }
15688
15689
15690 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15691 PyObject *pyobj;
15692
15693 {
15694 #if wxUSE_UNICODE
15695 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15696 #else
15697 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15698 #endif
15699 }
15700 return pyobj;
15701 }
15702
15703
15704 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15705 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15706 return 1;
15707 }
15708
15709
15710 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15711 PyObject *pyobj;
15712
15713 {
15714 #if wxUSE_UNICODE
15715 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15716 #else
15717 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15718 #endif
15719 }
15720 return pyobj;
15721 }
15722
15723
15724 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15725 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15726 return 1;
15727 }
15728
15729
15730 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15731 PyObject *pyobj;
15732
15733 {
15734 #if wxUSE_UNICODE
15735 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15736 #else
15737 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15738 #endif
15739 }
15740 return pyobj;
15741 }
15742
15743
15744 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15745 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15746 return 1;
15747 }
15748
15749
15750 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15751 PyObject *pyobj;
15752
15753 {
15754 #if wxUSE_UNICODE
15755 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15756 #else
15757 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15758 #endif
15759 }
15760 return pyobj;
15761 }
15762
15763
15764 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15765 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15766 return 1;
15767 }
15768
15769
15770 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15771 PyObject *pyobj;
15772
15773 {
15774 #if wxUSE_UNICODE
15775 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15776 #else
15777 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15778 #endif
15779 }
15780 return pyobj;
15781 }
15782
15783
15784 static int _wrap_ART_GO_BACK_set(PyObject *) {
15785 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15786 return 1;
15787 }
15788
15789
15790 static PyObject *_wrap_ART_GO_BACK_get(void) {
15791 PyObject *pyobj;
15792
15793 {
15794 #if wxUSE_UNICODE
15795 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15796 #else
15797 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15798 #endif
15799 }
15800 return pyobj;
15801 }
15802
15803
15804 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15805 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15806 return 1;
15807 }
15808
15809
15810 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15811 PyObject *pyobj;
15812
15813 {
15814 #if wxUSE_UNICODE
15815 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15816 #else
15817 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15818 #endif
15819 }
15820 return pyobj;
15821 }
15822
15823
15824 static int _wrap_ART_GO_UP_set(PyObject *) {
15825 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15826 return 1;
15827 }
15828
15829
15830 static PyObject *_wrap_ART_GO_UP_get(void) {
15831 PyObject *pyobj;
15832
15833 {
15834 #if wxUSE_UNICODE
15835 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15836 #else
15837 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15838 #endif
15839 }
15840 return pyobj;
15841 }
15842
15843
15844 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15845 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15846 return 1;
15847 }
15848
15849
15850 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15851 PyObject *pyobj;
15852
15853 {
15854 #if wxUSE_UNICODE
15855 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15856 #else
15857 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15858 #endif
15859 }
15860 return pyobj;
15861 }
15862
15863
15864 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15865 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15866 return 1;
15867 }
15868
15869
15870 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15871 PyObject *pyobj;
15872
15873 {
15874 #if wxUSE_UNICODE
15875 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15876 #else
15877 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15878 #endif
15879 }
15880 return pyobj;
15881 }
15882
15883
15884 static int _wrap_ART_GO_HOME_set(PyObject *) {
15885 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15886 return 1;
15887 }
15888
15889
15890 static PyObject *_wrap_ART_GO_HOME_get(void) {
15891 PyObject *pyobj;
15892
15893 {
15894 #if wxUSE_UNICODE
15895 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15896 #else
15897 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15898 #endif
15899 }
15900 return pyobj;
15901 }
15902
15903
15904 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15905 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15906 return 1;
15907 }
15908
15909
15910 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15911 PyObject *pyobj;
15912
15913 {
15914 #if wxUSE_UNICODE
15915 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15916 #else
15917 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15918 #endif
15919 }
15920 return pyobj;
15921 }
15922
15923
15924 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15925 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15926 return 1;
15927 }
15928
15929
15930 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15931 PyObject *pyobj;
15932
15933 {
15934 #if wxUSE_UNICODE
15935 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15936 #else
15937 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15938 #endif
15939 }
15940 return pyobj;
15941 }
15942
15943
15944 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15945 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15946 return 1;
15947 }
15948
15949
15950 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15951 PyObject *pyobj;
15952
15953 {
15954 #if wxUSE_UNICODE
15955 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15956 #else
15957 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15958 #endif
15959 }
15960 return pyobj;
15961 }
15962
15963
15964 static int _wrap_ART_PRINT_set(PyObject *) {
15965 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15966 return 1;
15967 }
15968
15969
15970 static PyObject *_wrap_ART_PRINT_get(void) {
15971 PyObject *pyobj;
15972
15973 {
15974 #if wxUSE_UNICODE
15975 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15976 #else
15977 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15978 #endif
15979 }
15980 return pyobj;
15981 }
15982
15983
15984 static int _wrap_ART_HELP_set(PyObject *) {
15985 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15986 return 1;
15987 }
15988
15989
15990 static PyObject *_wrap_ART_HELP_get(void) {
15991 PyObject *pyobj;
15992
15993 {
15994 #if wxUSE_UNICODE
15995 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15996 #else
15997 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15998 #endif
15999 }
16000 return pyobj;
16001 }
16002
16003
16004 static int _wrap_ART_TIP_set(PyObject *) {
16005 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16006 return 1;
16007 }
16008
16009
16010 static PyObject *_wrap_ART_TIP_get(void) {
16011 PyObject *pyobj;
16012
16013 {
16014 #if wxUSE_UNICODE
16015 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16016 #else
16017 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16018 #endif
16019 }
16020 return pyobj;
16021 }
16022
16023
16024 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16025 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16026 return 1;
16027 }
16028
16029
16030 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16031 PyObject *pyobj;
16032
16033 {
16034 #if wxUSE_UNICODE
16035 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16036 #else
16037 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16038 #endif
16039 }
16040 return pyobj;
16041 }
16042
16043
16044 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16045 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16046 return 1;
16047 }
16048
16049
16050 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16051 PyObject *pyobj;
16052
16053 {
16054 #if wxUSE_UNICODE
16055 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16056 #else
16057 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16058 #endif
16059 }
16060 return pyobj;
16061 }
16062
16063
16064 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16065 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16066 return 1;
16067 }
16068
16069
16070 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16071 PyObject *pyobj;
16072
16073 {
16074 #if wxUSE_UNICODE
16075 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16076 #else
16077 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16078 #endif
16079 }
16080 return pyobj;
16081 }
16082
16083
16084 static int _wrap_ART_HARDDISK_set(PyObject *) {
16085 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16086 return 1;
16087 }
16088
16089
16090 static PyObject *_wrap_ART_HARDDISK_get(void) {
16091 PyObject *pyobj;
16092
16093 {
16094 #if wxUSE_UNICODE
16095 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16096 #else
16097 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16098 #endif
16099 }
16100 return pyobj;
16101 }
16102
16103
16104 static int _wrap_ART_FLOPPY_set(PyObject *) {
16105 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16106 return 1;
16107 }
16108
16109
16110 static PyObject *_wrap_ART_FLOPPY_get(void) {
16111 PyObject *pyobj;
16112
16113 {
16114 #if wxUSE_UNICODE
16115 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16116 #else
16117 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16118 #endif
16119 }
16120 return pyobj;
16121 }
16122
16123
16124 static int _wrap_ART_CDROM_set(PyObject *) {
16125 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16126 return 1;
16127 }
16128
16129
16130 static PyObject *_wrap_ART_CDROM_get(void) {
16131 PyObject *pyobj;
16132
16133 {
16134 #if wxUSE_UNICODE
16135 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16136 #else
16137 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16138 #endif
16139 }
16140 return pyobj;
16141 }
16142
16143
16144 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16145 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16146 return 1;
16147 }
16148
16149
16150 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16151 PyObject *pyobj;
16152
16153 {
16154 #if wxUSE_UNICODE
16155 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16156 #else
16157 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16158 #endif
16159 }
16160 return pyobj;
16161 }
16162
16163
16164 static int _wrap_ART_FOLDER_set(PyObject *) {
16165 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16166 return 1;
16167 }
16168
16169
16170 static PyObject *_wrap_ART_FOLDER_get(void) {
16171 PyObject *pyobj;
16172
16173 {
16174 #if wxUSE_UNICODE
16175 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16176 #else
16177 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16178 #endif
16179 }
16180 return pyobj;
16181 }
16182
16183
16184 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16185 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16186 return 1;
16187 }
16188
16189
16190 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16191 PyObject *pyobj;
16192
16193 {
16194 #if wxUSE_UNICODE
16195 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16196 #else
16197 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16198 #endif
16199 }
16200 return pyobj;
16201 }
16202
16203
16204 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16205 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16206 return 1;
16207 }
16208
16209
16210 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16211 PyObject *pyobj;
16212
16213 {
16214 #if wxUSE_UNICODE
16215 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16216 #else
16217 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16218 #endif
16219 }
16220 return pyobj;
16221 }
16222
16223
16224 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16225 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16226 return 1;
16227 }
16228
16229
16230 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16231 PyObject *pyobj;
16232
16233 {
16234 #if wxUSE_UNICODE
16235 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16236 #else
16237 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16238 #endif
16239 }
16240 return pyobj;
16241 }
16242
16243
16244 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16245 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16246 return 1;
16247 }
16248
16249
16250 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16251 PyObject *pyobj;
16252
16253 {
16254 #if wxUSE_UNICODE
16255 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16256 #else
16257 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16258 #endif
16259 }
16260 return pyobj;
16261 }
16262
16263
16264 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16265 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16266 return 1;
16267 }
16268
16269
16270 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16271 PyObject *pyobj;
16272
16273 {
16274 #if wxUSE_UNICODE
16275 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16276 #else
16277 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16278 #endif
16279 }
16280 return pyobj;
16281 }
16282
16283
16284 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16285 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16286 return 1;
16287 }
16288
16289
16290 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16291 PyObject *pyobj;
16292
16293 {
16294 #if wxUSE_UNICODE
16295 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16296 #else
16297 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16298 #endif
16299 }
16300 return pyobj;
16301 }
16302
16303
16304 static int _wrap_ART_ERROR_set(PyObject *) {
16305 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16306 return 1;
16307 }
16308
16309
16310 static PyObject *_wrap_ART_ERROR_get(void) {
16311 PyObject *pyobj;
16312
16313 {
16314 #if wxUSE_UNICODE
16315 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16316 #else
16317 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16318 #endif
16319 }
16320 return pyobj;
16321 }
16322
16323
16324 static int _wrap_ART_QUESTION_set(PyObject *) {
16325 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16326 return 1;
16327 }
16328
16329
16330 static PyObject *_wrap_ART_QUESTION_get(void) {
16331 PyObject *pyobj;
16332
16333 {
16334 #if wxUSE_UNICODE
16335 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16336 #else
16337 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16338 #endif
16339 }
16340 return pyobj;
16341 }
16342
16343
16344 static int _wrap_ART_WARNING_set(PyObject *) {
16345 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16346 return 1;
16347 }
16348
16349
16350 static PyObject *_wrap_ART_WARNING_get(void) {
16351 PyObject *pyobj;
16352
16353 {
16354 #if wxUSE_UNICODE
16355 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16356 #else
16357 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16358 #endif
16359 }
16360 return pyobj;
16361 }
16362
16363
16364 static int _wrap_ART_INFORMATION_set(PyObject *) {
16365 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16366 return 1;
16367 }
16368
16369
16370 static PyObject *_wrap_ART_INFORMATION_get(void) {
16371 PyObject *pyobj;
16372
16373 {
16374 #if wxUSE_UNICODE
16375 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16376 #else
16377 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16378 #endif
16379 }
16380 return pyobj;
16381 }
16382
16383
16384 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16385 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16386 return 1;
16387 }
16388
16389
16390 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16391 PyObject *pyobj;
16392
16393 {
16394 #if wxUSE_UNICODE
16395 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16396 #else
16397 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16398 #endif
16399 }
16400 return pyobj;
16401 }
16402
16403
16404 static int _wrap_ART_COPY_set(PyObject *) {
16405 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16406 return 1;
16407 }
16408
16409
16410 static PyObject *_wrap_ART_COPY_get(void) {
16411 PyObject *pyobj;
16412
16413 {
16414 #if wxUSE_UNICODE
16415 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16416 #else
16417 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16418 #endif
16419 }
16420 return pyobj;
16421 }
16422
16423
16424 static int _wrap_ART_CUT_set(PyObject *) {
16425 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16426 return 1;
16427 }
16428
16429
16430 static PyObject *_wrap_ART_CUT_get(void) {
16431 PyObject *pyobj;
16432
16433 {
16434 #if wxUSE_UNICODE
16435 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16436 #else
16437 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16438 #endif
16439 }
16440 return pyobj;
16441 }
16442
16443
16444 static int _wrap_ART_PASTE_set(PyObject *) {
16445 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16446 return 1;
16447 }
16448
16449
16450 static PyObject *_wrap_ART_PASTE_get(void) {
16451 PyObject *pyobj;
16452
16453 {
16454 #if wxUSE_UNICODE
16455 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16456 #else
16457 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16458 #endif
16459 }
16460 return pyobj;
16461 }
16462
16463
16464 static int _wrap_ART_DELETE_set(PyObject *) {
16465 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16466 return 1;
16467 }
16468
16469
16470 static PyObject *_wrap_ART_DELETE_get(void) {
16471 PyObject *pyobj;
16472
16473 {
16474 #if wxUSE_UNICODE
16475 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16476 #else
16477 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16478 #endif
16479 }
16480 return pyobj;
16481 }
16482
16483
16484 static int _wrap_ART_NEW_set(PyObject *) {
16485 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW is read-only.");
16486 return 1;
16487 }
16488
16489
16490 static PyObject *_wrap_ART_NEW_get(void) {
16491 PyObject *pyobj;
16492
16493 {
16494 #if wxUSE_UNICODE
16495 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
16496 #else
16497 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
16498 #endif
16499 }
16500 return pyobj;
16501 }
16502
16503
16504 static int _wrap_ART_UNDO_set(PyObject *) {
16505 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16506 return 1;
16507 }
16508
16509
16510 static PyObject *_wrap_ART_UNDO_get(void) {
16511 PyObject *pyobj;
16512
16513 {
16514 #if wxUSE_UNICODE
16515 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16516 #else
16517 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16518 #endif
16519 }
16520 return pyobj;
16521 }
16522
16523
16524 static int _wrap_ART_REDO_set(PyObject *) {
16525 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16526 return 1;
16527 }
16528
16529
16530 static PyObject *_wrap_ART_REDO_get(void) {
16531 PyObject *pyobj;
16532
16533 {
16534 #if wxUSE_UNICODE
16535 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16536 #else
16537 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16538 #endif
16539 }
16540 return pyobj;
16541 }
16542
16543
16544 static int _wrap_ART_QUIT_set(PyObject *) {
16545 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16546 return 1;
16547 }
16548
16549
16550 static PyObject *_wrap_ART_QUIT_get(void) {
16551 PyObject *pyobj;
16552
16553 {
16554 #if wxUSE_UNICODE
16555 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16556 #else
16557 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16558 #endif
16559 }
16560 return pyobj;
16561 }
16562
16563
16564 static int _wrap_ART_FIND_set(PyObject *) {
16565 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16566 return 1;
16567 }
16568
16569
16570 static PyObject *_wrap_ART_FIND_get(void) {
16571 PyObject *pyobj;
16572
16573 {
16574 #if wxUSE_UNICODE
16575 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16576 #else
16577 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16578 #endif
16579 }
16580 return pyobj;
16581 }
16582
16583
16584 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16585 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16586 return 1;
16587 }
16588
16589
16590 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16591 PyObject *pyobj;
16592
16593 {
16594 #if wxUSE_UNICODE
16595 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16596 #else
16597 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16598 #endif
16599 }
16600 return pyobj;
16601 }
16602
16603
16604 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16605 PyObject *resultobj;
16606 wxPyArtProvider *result;
16607 char *kwnames[] = {
16608 NULL
16609 };
16610
16611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16612 {
16613 if (!wxPyCheckForApp()) SWIG_fail;
16614 PyThreadState* __tstate = wxPyBeginAllowThreads();
16615 result = (wxPyArtProvider *)new wxPyArtProvider();
16616
16617 wxPyEndAllowThreads(__tstate);
16618 if (PyErr_Occurred()) SWIG_fail;
16619 }
16620 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16621 return resultobj;
16622 fail:
16623 return NULL;
16624 }
16625
16626
16627 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16628 PyObject *resultobj;
16629 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16630 PyObject *arg2 = (PyObject *) 0 ;
16631 PyObject *arg3 = (PyObject *) 0 ;
16632 PyObject * obj0 = 0 ;
16633 PyObject * obj1 = 0 ;
16634 PyObject * obj2 = 0 ;
16635 char *kwnames[] = {
16636 (char *) "self",(char *) "self",(char *) "_class", NULL
16637 };
16638
16639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16641 if (SWIG_arg_fail(1)) SWIG_fail;
16642 arg2 = obj1;
16643 arg3 = obj2;
16644 {
16645 PyThreadState* __tstate = wxPyBeginAllowThreads();
16646 (arg1)->_setCallbackInfo(arg2,arg3);
16647
16648 wxPyEndAllowThreads(__tstate);
16649 if (PyErr_Occurred()) SWIG_fail;
16650 }
16651 Py_INCREF(Py_None); resultobj = Py_None;
16652 return resultobj;
16653 fail:
16654 return NULL;
16655 }
16656
16657
16658 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16659 PyObject *resultobj;
16660 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16661 PyObject * obj0 = 0 ;
16662 char *kwnames[] = {
16663 (char *) "provider", NULL
16664 };
16665
16666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16668 if (SWIG_arg_fail(1)) SWIG_fail;
16669 {
16670 PyThreadState* __tstate = wxPyBeginAllowThreads();
16671 wxPyArtProvider::PushProvider(arg1);
16672
16673 wxPyEndAllowThreads(__tstate);
16674 if (PyErr_Occurred()) SWIG_fail;
16675 }
16676 Py_INCREF(Py_None); resultobj = Py_None;
16677 return resultobj;
16678 fail:
16679 return NULL;
16680 }
16681
16682
16683 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16684 PyObject *resultobj;
16685 bool result;
16686 char *kwnames[] = {
16687 NULL
16688 };
16689
16690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16691 {
16692 PyThreadState* __tstate = wxPyBeginAllowThreads();
16693 result = (bool)wxPyArtProvider::PopProvider();
16694
16695 wxPyEndAllowThreads(__tstate);
16696 if (PyErr_Occurred()) SWIG_fail;
16697 }
16698 {
16699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16700 }
16701 return resultobj;
16702 fail:
16703 return NULL;
16704 }
16705
16706
16707 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16708 PyObject *resultobj;
16709 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16710 bool result;
16711 PyObject * obj0 = 0 ;
16712 char *kwnames[] = {
16713 (char *) "provider", NULL
16714 };
16715
16716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16718 if (SWIG_arg_fail(1)) SWIG_fail;
16719 {
16720 PyThreadState* __tstate = wxPyBeginAllowThreads();
16721 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16722
16723 wxPyEndAllowThreads(__tstate);
16724 if (PyErr_Occurred()) SWIG_fail;
16725 }
16726 {
16727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16728 }
16729 return resultobj;
16730 fail:
16731 return NULL;
16732 }
16733
16734
16735 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16736 PyObject *resultobj;
16737 wxString *arg1 = 0 ;
16738 wxString const &arg2_defvalue = wxPyART_OTHER ;
16739 wxString *arg2 = (wxString *) &arg2_defvalue ;
16740 wxSize const &arg3_defvalue = wxDefaultSize ;
16741 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16742 wxBitmap result;
16743 bool temp1 = false ;
16744 bool temp2 = false ;
16745 wxSize temp3 ;
16746 PyObject * obj0 = 0 ;
16747 PyObject * obj1 = 0 ;
16748 PyObject * obj2 = 0 ;
16749 char *kwnames[] = {
16750 (char *) "id",(char *) "client",(char *) "size", NULL
16751 };
16752
16753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16754 {
16755 arg1 = wxString_in_helper(obj0);
16756 if (arg1 == NULL) SWIG_fail;
16757 temp1 = true;
16758 }
16759 if (obj1) {
16760 {
16761 arg2 = wxString_in_helper(obj1);
16762 if (arg2 == NULL) SWIG_fail;
16763 temp2 = true;
16764 }
16765 }
16766 if (obj2) {
16767 {
16768 arg3 = &temp3;
16769 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16770 }
16771 }
16772 {
16773 if (!wxPyCheckForApp()) SWIG_fail;
16774 PyThreadState* __tstate = wxPyBeginAllowThreads();
16775 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16776
16777 wxPyEndAllowThreads(__tstate);
16778 if (PyErr_Occurred()) SWIG_fail;
16779 }
16780 {
16781 wxBitmap * resultptr;
16782 resultptr = new wxBitmap((wxBitmap &)(result));
16783 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16784 }
16785 {
16786 if (temp1)
16787 delete arg1;
16788 }
16789 {
16790 if (temp2)
16791 delete arg2;
16792 }
16793 return resultobj;
16794 fail:
16795 {
16796 if (temp1)
16797 delete arg1;
16798 }
16799 {
16800 if (temp2)
16801 delete arg2;
16802 }
16803 return NULL;
16804 }
16805
16806
16807 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16808 PyObject *resultobj;
16809 wxString *arg1 = 0 ;
16810 wxString const &arg2_defvalue = wxPyART_OTHER ;
16811 wxString *arg2 = (wxString *) &arg2_defvalue ;
16812 wxSize const &arg3_defvalue = wxDefaultSize ;
16813 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16814 wxIcon result;
16815 bool temp1 = false ;
16816 bool temp2 = false ;
16817 wxSize temp3 ;
16818 PyObject * obj0 = 0 ;
16819 PyObject * obj1 = 0 ;
16820 PyObject * obj2 = 0 ;
16821 char *kwnames[] = {
16822 (char *) "id",(char *) "client",(char *) "size", NULL
16823 };
16824
16825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16826 {
16827 arg1 = wxString_in_helper(obj0);
16828 if (arg1 == NULL) SWIG_fail;
16829 temp1 = true;
16830 }
16831 if (obj1) {
16832 {
16833 arg2 = wxString_in_helper(obj1);
16834 if (arg2 == NULL) SWIG_fail;
16835 temp2 = true;
16836 }
16837 }
16838 if (obj2) {
16839 {
16840 arg3 = &temp3;
16841 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16842 }
16843 }
16844 {
16845 if (!wxPyCheckForApp()) SWIG_fail;
16846 PyThreadState* __tstate = wxPyBeginAllowThreads();
16847 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16848
16849 wxPyEndAllowThreads(__tstate);
16850 if (PyErr_Occurred()) SWIG_fail;
16851 }
16852 {
16853 wxIcon * resultptr;
16854 resultptr = new wxIcon((wxIcon &)(result));
16855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16856 }
16857 {
16858 if (temp1)
16859 delete arg1;
16860 }
16861 {
16862 if (temp2)
16863 delete arg2;
16864 }
16865 return resultobj;
16866 fail:
16867 {
16868 if (temp1)
16869 delete arg1;
16870 }
16871 {
16872 if (temp2)
16873 delete arg2;
16874 }
16875 return NULL;
16876 }
16877
16878
16879 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16880 PyObject *resultobj;
16881 wxString *arg1 = 0 ;
16882 bool arg2 = (bool) false ;
16883 wxSize result;
16884 bool temp1 = false ;
16885 PyObject * obj0 = 0 ;
16886 PyObject * obj1 = 0 ;
16887 char *kwnames[] = {
16888 (char *) "client",(char *) "platform_dependent", NULL
16889 };
16890
16891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16892 {
16893 arg1 = wxString_in_helper(obj0);
16894 if (arg1 == NULL) SWIG_fail;
16895 temp1 = true;
16896 }
16897 if (obj1) {
16898 {
16899 arg2 = (bool)(SWIG_As_bool(obj1));
16900 if (SWIG_arg_fail(2)) SWIG_fail;
16901 }
16902 }
16903 {
16904 PyThreadState* __tstate = wxPyBeginAllowThreads();
16905 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16906
16907 wxPyEndAllowThreads(__tstate);
16908 if (PyErr_Occurred()) SWIG_fail;
16909 }
16910 {
16911 wxSize * resultptr;
16912 resultptr = new wxSize((wxSize &)(result));
16913 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16914 }
16915 {
16916 if (temp1)
16917 delete arg1;
16918 }
16919 return resultobj;
16920 fail:
16921 {
16922 if (temp1)
16923 delete arg1;
16924 }
16925 return NULL;
16926 }
16927
16928
16929 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16930 PyObject *resultobj;
16931 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16932 PyObject * obj0 = 0 ;
16933 char *kwnames[] = {
16934 (char *) "self", NULL
16935 };
16936
16937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16939 if (SWIG_arg_fail(1)) SWIG_fail;
16940 {
16941 PyThreadState* __tstate = wxPyBeginAllowThreads();
16942 wxPyArtProvider_Destroy(arg1);
16943
16944 wxPyEndAllowThreads(__tstate);
16945 if (PyErr_Occurred()) SWIG_fail;
16946 }
16947 Py_INCREF(Py_None); resultobj = Py_None;
16948 return resultobj;
16949 fail:
16950 return NULL;
16951 }
16952
16953
16954 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16955 PyObject *obj;
16956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16957 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16958 Py_INCREF(obj);
16959 return Py_BuildValue((char *)"");
16960 }
16961 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16962 PyObject *resultobj;
16963 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16964 PyObject * obj0 = 0 ;
16965 char *kwnames[] = {
16966 (char *) "self", NULL
16967 };
16968
16969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16971 if (SWIG_arg_fail(1)) SWIG_fail;
16972 {
16973 PyThreadState* __tstate = wxPyBeginAllowThreads();
16974 delete arg1;
16975
16976 wxPyEndAllowThreads(__tstate);
16977 if (PyErr_Occurred()) SWIG_fail;
16978 }
16979 Py_INCREF(Py_None); resultobj = Py_None;
16980 return resultobj;
16981 fail:
16982 return NULL;
16983 }
16984
16985
16986 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16987 PyObject *resultobj;
16988 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16989 wxConfigBase *result;
16990 PyObject * obj0 = 0 ;
16991 char *kwnames[] = {
16992 (char *) "config", NULL
16993 };
16994
16995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
16997 if (SWIG_arg_fail(1)) SWIG_fail;
16998 {
16999 PyThreadState* __tstate = wxPyBeginAllowThreads();
17000 result = (wxConfigBase *)wxConfigBase::Set(arg1);
17001
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17006 return resultobj;
17007 fail:
17008 return NULL;
17009 }
17010
17011
17012 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
17013 PyObject *resultobj;
17014 bool arg1 = (bool) true ;
17015 wxConfigBase *result;
17016 PyObject * obj0 = 0 ;
17017 char *kwnames[] = {
17018 (char *) "createOnDemand", NULL
17019 };
17020
17021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
17022 if (obj0) {
17023 {
17024 arg1 = (bool)(SWIG_As_bool(obj0));
17025 if (SWIG_arg_fail(1)) SWIG_fail;
17026 }
17027 }
17028 {
17029 PyThreadState* __tstate = wxPyBeginAllowThreads();
17030 result = (wxConfigBase *)wxConfigBase::Get(arg1);
17031
17032 wxPyEndAllowThreads(__tstate);
17033 if (PyErr_Occurred()) SWIG_fail;
17034 }
17035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17036 return resultobj;
17037 fail:
17038 return NULL;
17039 }
17040
17041
17042 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17043 PyObject *resultobj;
17044 wxConfigBase *result;
17045 char *kwnames[] = {
17046 NULL
17047 };
17048
17049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17050 {
17051 PyThreadState* __tstate = wxPyBeginAllowThreads();
17052 result = (wxConfigBase *)wxConfigBase::Create();
17053
17054 wxPyEndAllowThreads(__tstate);
17055 if (PyErr_Occurred()) SWIG_fail;
17056 }
17057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17058 return resultobj;
17059 fail:
17060 return NULL;
17061 }
17062
17063
17064 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17065 PyObject *resultobj;
17066 char *kwnames[] = {
17067 NULL
17068 };
17069
17070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17071 {
17072 PyThreadState* __tstate = wxPyBeginAllowThreads();
17073 wxConfigBase::DontCreateOnDemand();
17074
17075 wxPyEndAllowThreads(__tstate);
17076 if (PyErr_Occurred()) SWIG_fail;
17077 }
17078 Py_INCREF(Py_None); resultobj = Py_None;
17079 return resultobj;
17080 fail:
17081 return NULL;
17082 }
17083
17084
17085 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17086 PyObject *resultobj;
17087 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17088 wxString *arg2 = 0 ;
17089 bool temp2 = false ;
17090 PyObject * obj0 = 0 ;
17091 PyObject * obj1 = 0 ;
17092 char *kwnames[] = {
17093 (char *) "self",(char *) "path", NULL
17094 };
17095
17096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17098 if (SWIG_arg_fail(1)) SWIG_fail;
17099 {
17100 arg2 = wxString_in_helper(obj1);
17101 if (arg2 == NULL) SWIG_fail;
17102 temp2 = true;
17103 }
17104 {
17105 PyThreadState* __tstate = wxPyBeginAllowThreads();
17106 (arg1)->SetPath((wxString const &)*arg2);
17107
17108 wxPyEndAllowThreads(__tstate);
17109 if (PyErr_Occurred()) SWIG_fail;
17110 }
17111 Py_INCREF(Py_None); resultobj = Py_None;
17112 {
17113 if (temp2)
17114 delete arg2;
17115 }
17116 return resultobj;
17117 fail:
17118 {
17119 if (temp2)
17120 delete arg2;
17121 }
17122 return NULL;
17123 }
17124
17125
17126 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17127 PyObject *resultobj;
17128 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17129 wxString *result;
17130 PyObject * obj0 = 0 ;
17131 char *kwnames[] = {
17132 (char *) "self", NULL
17133 };
17134
17135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17137 if (SWIG_arg_fail(1)) SWIG_fail;
17138 {
17139 PyThreadState* __tstate = wxPyBeginAllowThreads();
17140 {
17141 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17142 result = (wxString *) &_result_ref;
17143 }
17144
17145 wxPyEndAllowThreads(__tstate);
17146 if (PyErr_Occurred()) SWIG_fail;
17147 }
17148 {
17149 #if wxUSE_UNICODE
17150 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17151 #else
17152 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17153 #endif
17154 }
17155 return resultobj;
17156 fail:
17157 return NULL;
17158 }
17159
17160
17161 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17162 PyObject *resultobj;
17163 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17164 PyObject *result;
17165 PyObject * obj0 = 0 ;
17166 char *kwnames[] = {
17167 (char *) "self", NULL
17168 };
17169
17170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17172 if (SWIG_arg_fail(1)) SWIG_fail;
17173 {
17174 PyThreadState* __tstate = wxPyBeginAllowThreads();
17175 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17176
17177 wxPyEndAllowThreads(__tstate);
17178 if (PyErr_Occurred()) SWIG_fail;
17179 }
17180 resultobj = result;
17181 return resultobj;
17182 fail:
17183 return NULL;
17184 }
17185
17186
17187 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17188 PyObject *resultobj;
17189 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17190 long arg2 ;
17191 PyObject *result;
17192 PyObject * obj0 = 0 ;
17193 PyObject * obj1 = 0 ;
17194 char *kwnames[] = {
17195 (char *) "self",(char *) "index", NULL
17196 };
17197
17198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17200 if (SWIG_arg_fail(1)) SWIG_fail;
17201 {
17202 arg2 = (long)(SWIG_As_long(obj1));
17203 if (SWIG_arg_fail(2)) SWIG_fail;
17204 }
17205 {
17206 PyThreadState* __tstate = wxPyBeginAllowThreads();
17207 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17208
17209 wxPyEndAllowThreads(__tstate);
17210 if (PyErr_Occurred()) SWIG_fail;
17211 }
17212 resultobj = result;
17213 return resultobj;
17214 fail:
17215 return NULL;
17216 }
17217
17218
17219 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17220 PyObject *resultobj;
17221 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17222 PyObject *result;
17223 PyObject * obj0 = 0 ;
17224 char *kwnames[] = {
17225 (char *) "self", NULL
17226 };
17227
17228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17230 if (SWIG_arg_fail(1)) SWIG_fail;
17231 {
17232 PyThreadState* __tstate = wxPyBeginAllowThreads();
17233 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17234
17235 wxPyEndAllowThreads(__tstate);
17236 if (PyErr_Occurred()) SWIG_fail;
17237 }
17238 resultobj = result;
17239 return resultobj;
17240 fail:
17241 return NULL;
17242 }
17243
17244
17245 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17246 PyObject *resultobj;
17247 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17248 long arg2 ;
17249 PyObject *result;
17250 PyObject * obj0 = 0 ;
17251 PyObject * obj1 = 0 ;
17252 char *kwnames[] = {
17253 (char *) "self",(char *) "index", NULL
17254 };
17255
17256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17258 if (SWIG_arg_fail(1)) SWIG_fail;
17259 {
17260 arg2 = (long)(SWIG_As_long(obj1));
17261 if (SWIG_arg_fail(2)) SWIG_fail;
17262 }
17263 {
17264 PyThreadState* __tstate = wxPyBeginAllowThreads();
17265 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17266
17267 wxPyEndAllowThreads(__tstate);
17268 if (PyErr_Occurred()) SWIG_fail;
17269 }
17270 resultobj = result;
17271 return resultobj;
17272 fail:
17273 return NULL;
17274 }
17275
17276
17277 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17278 PyObject *resultobj;
17279 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17280 bool arg2 = (bool) false ;
17281 size_t result;
17282 PyObject * obj0 = 0 ;
17283 PyObject * obj1 = 0 ;
17284 char *kwnames[] = {
17285 (char *) "self",(char *) "recursive", NULL
17286 };
17287
17288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17290 if (SWIG_arg_fail(1)) SWIG_fail;
17291 if (obj1) {
17292 {
17293 arg2 = (bool)(SWIG_As_bool(obj1));
17294 if (SWIG_arg_fail(2)) SWIG_fail;
17295 }
17296 }
17297 {
17298 PyThreadState* __tstate = wxPyBeginAllowThreads();
17299 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17300
17301 wxPyEndAllowThreads(__tstate);
17302 if (PyErr_Occurred()) SWIG_fail;
17303 }
17304 {
17305 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17306 }
17307 return resultobj;
17308 fail:
17309 return NULL;
17310 }
17311
17312
17313 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17314 PyObject *resultobj;
17315 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17316 bool arg2 = (bool) false ;
17317 size_t result;
17318 PyObject * obj0 = 0 ;
17319 PyObject * obj1 = 0 ;
17320 char *kwnames[] = {
17321 (char *) "self",(char *) "recursive", NULL
17322 };
17323
17324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17326 if (SWIG_arg_fail(1)) SWIG_fail;
17327 if (obj1) {
17328 {
17329 arg2 = (bool)(SWIG_As_bool(obj1));
17330 if (SWIG_arg_fail(2)) SWIG_fail;
17331 }
17332 }
17333 {
17334 PyThreadState* __tstate = wxPyBeginAllowThreads();
17335 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17336
17337 wxPyEndAllowThreads(__tstate);
17338 if (PyErr_Occurred()) SWIG_fail;
17339 }
17340 {
17341 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17342 }
17343 return resultobj;
17344 fail:
17345 return NULL;
17346 }
17347
17348
17349 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17350 PyObject *resultobj;
17351 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17352 wxString *arg2 = 0 ;
17353 bool result;
17354 bool temp2 = false ;
17355 PyObject * obj0 = 0 ;
17356 PyObject * obj1 = 0 ;
17357 char *kwnames[] = {
17358 (char *) "self",(char *) "name", NULL
17359 };
17360
17361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17363 if (SWIG_arg_fail(1)) SWIG_fail;
17364 {
17365 arg2 = wxString_in_helper(obj1);
17366 if (arg2 == NULL) SWIG_fail;
17367 temp2 = true;
17368 }
17369 {
17370 PyThreadState* __tstate = wxPyBeginAllowThreads();
17371 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17372
17373 wxPyEndAllowThreads(__tstate);
17374 if (PyErr_Occurred()) SWIG_fail;
17375 }
17376 {
17377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17378 }
17379 {
17380 if (temp2)
17381 delete arg2;
17382 }
17383 return resultobj;
17384 fail:
17385 {
17386 if (temp2)
17387 delete arg2;
17388 }
17389 return NULL;
17390 }
17391
17392
17393 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17394 PyObject *resultobj;
17395 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17396 wxString *arg2 = 0 ;
17397 bool result;
17398 bool temp2 = false ;
17399 PyObject * obj0 = 0 ;
17400 PyObject * obj1 = 0 ;
17401 char *kwnames[] = {
17402 (char *) "self",(char *) "name", NULL
17403 };
17404
17405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17407 if (SWIG_arg_fail(1)) SWIG_fail;
17408 {
17409 arg2 = wxString_in_helper(obj1);
17410 if (arg2 == NULL) SWIG_fail;
17411 temp2 = true;
17412 }
17413 {
17414 PyThreadState* __tstate = wxPyBeginAllowThreads();
17415 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17416
17417 wxPyEndAllowThreads(__tstate);
17418 if (PyErr_Occurred()) SWIG_fail;
17419 }
17420 {
17421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17422 }
17423 {
17424 if (temp2)
17425 delete arg2;
17426 }
17427 return resultobj;
17428 fail:
17429 {
17430 if (temp2)
17431 delete arg2;
17432 }
17433 return NULL;
17434 }
17435
17436
17437 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17438 PyObject *resultobj;
17439 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17440 wxString *arg2 = 0 ;
17441 bool result;
17442 bool temp2 = false ;
17443 PyObject * obj0 = 0 ;
17444 PyObject * obj1 = 0 ;
17445 char *kwnames[] = {
17446 (char *) "self",(char *) "name", NULL
17447 };
17448
17449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17451 if (SWIG_arg_fail(1)) SWIG_fail;
17452 {
17453 arg2 = wxString_in_helper(obj1);
17454 if (arg2 == NULL) SWIG_fail;
17455 temp2 = true;
17456 }
17457 {
17458 PyThreadState* __tstate = wxPyBeginAllowThreads();
17459 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17460
17461 wxPyEndAllowThreads(__tstate);
17462 if (PyErr_Occurred()) SWIG_fail;
17463 }
17464 {
17465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17466 }
17467 {
17468 if (temp2)
17469 delete arg2;
17470 }
17471 return resultobj;
17472 fail:
17473 {
17474 if (temp2)
17475 delete arg2;
17476 }
17477 return NULL;
17478 }
17479
17480
17481 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17482 PyObject *resultobj;
17483 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17484 wxString *arg2 = 0 ;
17485 wxConfigBase::EntryType result;
17486 bool temp2 = false ;
17487 PyObject * obj0 = 0 ;
17488 PyObject * obj1 = 0 ;
17489 char *kwnames[] = {
17490 (char *) "self",(char *) "name", NULL
17491 };
17492
17493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17495 if (SWIG_arg_fail(1)) SWIG_fail;
17496 {
17497 arg2 = wxString_in_helper(obj1);
17498 if (arg2 == NULL) SWIG_fail;
17499 temp2 = true;
17500 }
17501 {
17502 PyThreadState* __tstate = wxPyBeginAllowThreads();
17503 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17504
17505 wxPyEndAllowThreads(__tstate);
17506 if (PyErr_Occurred()) SWIG_fail;
17507 }
17508 resultobj = SWIG_From_int((result));
17509 {
17510 if (temp2)
17511 delete arg2;
17512 }
17513 return resultobj;
17514 fail:
17515 {
17516 if (temp2)
17517 delete arg2;
17518 }
17519 return NULL;
17520 }
17521
17522
17523 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17524 PyObject *resultobj;
17525 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17526 wxString *arg2 = 0 ;
17527 wxString const &arg3_defvalue = wxPyEmptyString ;
17528 wxString *arg3 = (wxString *) &arg3_defvalue ;
17529 wxString result;
17530 bool temp2 = false ;
17531 bool temp3 = false ;
17532 PyObject * obj0 = 0 ;
17533 PyObject * obj1 = 0 ;
17534 PyObject * obj2 = 0 ;
17535 char *kwnames[] = {
17536 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17537 };
17538
17539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17541 if (SWIG_arg_fail(1)) SWIG_fail;
17542 {
17543 arg2 = wxString_in_helper(obj1);
17544 if (arg2 == NULL) SWIG_fail;
17545 temp2 = true;
17546 }
17547 if (obj2) {
17548 {
17549 arg3 = wxString_in_helper(obj2);
17550 if (arg3 == NULL) SWIG_fail;
17551 temp3 = true;
17552 }
17553 }
17554 {
17555 PyThreadState* __tstate = wxPyBeginAllowThreads();
17556 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17557
17558 wxPyEndAllowThreads(__tstate);
17559 if (PyErr_Occurred()) SWIG_fail;
17560 }
17561 {
17562 #if wxUSE_UNICODE
17563 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17564 #else
17565 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17566 #endif
17567 }
17568 {
17569 if (temp2)
17570 delete arg2;
17571 }
17572 {
17573 if (temp3)
17574 delete arg3;
17575 }
17576 return resultobj;
17577 fail:
17578 {
17579 if (temp2)
17580 delete arg2;
17581 }
17582 {
17583 if (temp3)
17584 delete arg3;
17585 }
17586 return NULL;
17587 }
17588
17589
17590 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17591 PyObject *resultobj;
17592 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17593 wxString *arg2 = 0 ;
17594 long arg3 = (long) 0 ;
17595 long result;
17596 bool temp2 = false ;
17597 PyObject * obj0 = 0 ;
17598 PyObject * obj1 = 0 ;
17599 PyObject * obj2 = 0 ;
17600 char *kwnames[] = {
17601 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17602 };
17603
17604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17606 if (SWIG_arg_fail(1)) SWIG_fail;
17607 {
17608 arg2 = wxString_in_helper(obj1);
17609 if (arg2 == NULL) SWIG_fail;
17610 temp2 = true;
17611 }
17612 if (obj2) {
17613 {
17614 arg3 = (long)(SWIG_As_long(obj2));
17615 if (SWIG_arg_fail(3)) SWIG_fail;
17616 }
17617 }
17618 {
17619 PyThreadState* __tstate = wxPyBeginAllowThreads();
17620 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17621
17622 wxPyEndAllowThreads(__tstate);
17623 if (PyErr_Occurred()) SWIG_fail;
17624 }
17625 {
17626 resultobj = SWIG_From_long((long)(result));
17627 }
17628 {
17629 if (temp2)
17630 delete arg2;
17631 }
17632 return resultobj;
17633 fail:
17634 {
17635 if (temp2)
17636 delete arg2;
17637 }
17638 return NULL;
17639 }
17640
17641
17642 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17643 PyObject *resultobj;
17644 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17645 wxString *arg2 = 0 ;
17646 double arg3 = (double) 0.0 ;
17647 double result;
17648 bool temp2 = false ;
17649 PyObject * obj0 = 0 ;
17650 PyObject * obj1 = 0 ;
17651 PyObject * obj2 = 0 ;
17652 char *kwnames[] = {
17653 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17654 };
17655
17656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17658 if (SWIG_arg_fail(1)) SWIG_fail;
17659 {
17660 arg2 = wxString_in_helper(obj1);
17661 if (arg2 == NULL) SWIG_fail;
17662 temp2 = true;
17663 }
17664 if (obj2) {
17665 {
17666 arg3 = (double)(SWIG_As_double(obj2));
17667 if (SWIG_arg_fail(3)) SWIG_fail;
17668 }
17669 }
17670 {
17671 PyThreadState* __tstate = wxPyBeginAllowThreads();
17672 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17673
17674 wxPyEndAllowThreads(__tstate);
17675 if (PyErr_Occurred()) SWIG_fail;
17676 }
17677 {
17678 resultobj = SWIG_From_double((double)(result));
17679 }
17680 {
17681 if (temp2)
17682 delete arg2;
17683 }
17684 return resultobj;
17685 fail:
17686 {
17687 if (temp2)
17688 delete arg2;
17689 }
17690 return NULL;
17691 }
17692
17693
17694 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17695 PyObject *resultobj;
17696 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17697 wxString *arg2 = 0 ;
17698 bool arg3 = (bool) false ;
17699 bool result;
17700 bool temp2 = false ;
17701 PyObject * obj0 = 0 ;
17702 PyObject * obj1 = 0 ;
17703 PyObject * obj2 = 0 ;
17704 char *kwnames[] = {
17705 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17706 };
17707
17708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17710 if (SWIG_arg_fail(1)) SWIG_fail;
17711 {
17712 arg2 = wxString_in_helper(obj1);
17713 if (arg2 == NULL) SWIG_fail;
17714 temp2 = true;
17715 }
17716 if (obj2) {
17717 {
17718 arg3 = (bool)(SWIG_As_bool(obj2));
17719 if (SWIG_arg_fail(3)) SWIG_fail;
17720 }
17721 }
17722 {
17723 PyThreadState* __tstate = wxPyBeginAllowThreads();
17724 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17725
17726 wxPyEndAllowThreads(__tstate);
17727 if (PyErr_Occurred()) SWIG_fail;
17728 }
17729 {
17730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17731 }
17732 {
17733 if (temp2)
17734 delete arg2;
17735 }
17736 return resultobj;
17737 fail:
17738 {
17739 if (temp2)
17740 delete arg2;
17741 }
17742 return NULL;
17743 }
17744
17745
17746 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17747 PyObject *resultobj;
17748 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17749 wxString *arg2 = 0 ;
17750 wxString *arg3 = 0 ;
17751 bool result;
17752 bool temp2 = false ;
17753 bool temp3 = false ;
17754 PyObject * obj0 = 0 ;
17755 PyObject * obj1 = 0 ;
17756 PyObject * obj2 = 0 ;
17757 char *kwnames[] = {
17758 (char *) "self",(char *) "key",(char *) "value", NULL
17759 };
17760
17761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17763 if (SWIG_arg_fail(1)) SWIG_fail;
17764 {
17765 arg2 = wxString_in_helper(obj1);
17766 if (arg2 == NULL) SWIG_fail;
17767 temp2 = true;
17768 }
17769 {
17770 arg3 = wxString_in_helper(obj2);
17771 if (arg3 == NULL) SWIG_fail;
17772 temp3 = true;
17773 }
17774 {
17775 PyThreadState* __tstate = wxPyBeginAllowThreads();
17776 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17777
17778 wxPyEndAllowThreads(__tstate);
17779 if (PyErr_Occurred()) SWIG_fail;
17780 }
17781 {
17782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17783 }
17784 {
17785 if (temp2)
17786 delete arg2;
17787 }
17788 {
17789 if (temp3)
17790 delete arg3;
17791 }
17792 return resultobj;
17793 fail:
17794 {
17795 if (temp2)
17796 delete arg2;
17797 }
17798 {
17799 if (temp3)
17800 delete arg3;
17801 }
17802 return NULL;
17803 }
17804
17805
17806 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17807 PyObject *resultobj;
17808 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17809 wxString *arg2 = 0 ;
17810 long arg3 ;
17811 bool result;
17812 bool temp2 = false ;
17813 PyObject * obj0 = 0 ;
17814 PyObject * obj1 = 0 ;
17815 PyObject * obj2 = 0 ;
17816 char *kwnames[] = {
17817 (char *) "self",(char *) "key",(char *) "value", NULL
17818 };
17819
17820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17822 if (SWIG_arg_fail(1)) SWIG_fail;
17823 {
17824 arg2 = wxString_in_helper(obj1);
17825 if (arg2 == NULL) SWIG_fail;
17826 temp2 = true;
17827 }
17828 {
17829 arg3 = (long)(SWIG_As_long(obj2));
17830 if (SWIG_arg_fail(3)) SWIG_fail;
17831 }
17832 {
17833 PyThreadState* __tstate = wxPyBeginAllowThreads();
17834 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17835
17836 wxPyEndAllowThreads(__tstate);
17837 if (PyErr_Occurred()) SWIG_fail;
17838 }
17839 {
17840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17841 }
17842 {
17843 if (temp2)
17844 delete arg2;
17845 }
17846 return resultobj;
17847 fail:
17848 {
17849 if (temp2)
17850 delete arg2;
17851 }
17852 return NULL;
17853 }
17854
17855
17856 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17857 PyObject *resultobj;
17858 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17859 wxString *arg2 = 0 ;
17860 double arg3 ;
17861 bool result;
17862 bool temp2 = false ;
17863 PyObject * obj0 = 0 ;
17864 PyObject * obj1 = 0 ;
17865 PyObject * obj2 = 0 ;
17866 char *kwnames[] = {
17867 (char *) "self",(char *) "key",(char *) "value", NULL
17868 };
17869
17870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17872 if (SWIG_arg_fail(1)) SWIG_fail;
17873 {
17874 arg2 = wxString_in_helper(obj1);
17875 if (arg2 == NULL) SWIG_fail;
17876 temp2 = true;
17877 }
17878 {
17879 arg3 = (double)(SWIG_As_double(obj2));
17880 if (SWIG_arg_fail(3)) SWIG_fail;
17881 }
17882 {
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17885
17886 wxPyEndAllowThreads(__tstate);
17887 if (PyErr_Occurred()) SWIG_fail;
17888 }
17889 {
17890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17891 }
17892 {
17893 if (temp2)
17894 delete arg2;
17895 }
17896 return resultobj;
17897 fail:
17898 {
17899 if (temp2)
17900 delete arg2;
17901 }
17902 return NULL;
17903 }
17904
17905
17906 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17907 PyObject *resultobj;
17908 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17909 wxString *arg2 = 0 ;
17910 bool arg3 ;
17911 bool result;
17912 bool temp2 = false ;
17913 PyObject * obj0 = 0 ;
17914 PyObject * obj1 = 0 ;
17915 PyObject * obj2 = 0 ;
17916 char *kwnames[] = {
17917 (char *) "self",(char *) "key",(char *) "value", NULL
17918 };
17919
17920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17922 if (SWIG_arg_fail(1)) SWIG_fail;
17923 {
17924 arg2 = wxString_in_helper(obj1);
17925 if (arg2 == NULL) SWIG_fail;
17926 temp2 = true;
17927 }
17928 {
17929 arg3 = (bool)(SWIG_As_bool(obj2));
17930 if (SWIG_arg_fail(3)) SWIG_fail;
17931 }
17932 {
17933 PyThreadState* __tstate = wxPyBeginAllowThreads();
17934 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17935
17936 wxPyEndAllowThreads(__tstate);
17937 if (PyErr_Occurred()) SWIG_fail;
17938 }
17939 {
17940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17941 }
17942 {
17943 if (temp2)
17944 delete arg2;
17945 }
17946 return resultobj;
17947 fail:
17948 {
17949 if (temp2)
17950 delete arg2;
17951 }
17952 return NULL;
17953 }
17954
17955
17956 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17957 PyObject *resultobj;
17958 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17959 bool arg2 = (bool) false ;
17960 bool result;
17961 PyObject * obj0 = 0 ;
17962 PyObject * obj1 = 0 ;
17963 char *kwnames[] = {
17964 (char *) "self",(char *) "currentOnly", NULL
17965 };
17966
17967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17969 if (SWIG_arg_fail(1)) SWIG_fail;
17970 if (obj1) {
17971 {
17972 arg2 = (bool)(SWIG_As_bool(obj1));
17973 if (SWIG_arg_fail(2)) SWIG_fail;
17974 }
17975 }
17976 {
17977 PyThreadState* __tstate = wxPyBeginAllowThreads();
17978 result = (bool)(arg1)->Flush(arg2);
17979
17980 wxPyEndAllowThreads(__tstate);
17981 if (PyErr_Occurred()) SWIG_fail;
17982 }
17983 {
17984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17985 }
17986 return resultobj;
17987 fail:
17988 return NULL;
17989 }
17990
17991
17992 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17993 PyObject *resultobj;
17994 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17995 wxString *arg2 = 0 ;
17996 wxString *arg3 = 0 ;
17997 bool result;
17998 bool temp2 = false ;
17999 bool temp3 = false ;
18000 PyObject * obj0 = 0 ;
18001 PyObject * obj1 = 0 ;
18002 PyObject * obj2 = 0 ;
18003 char *kwnames[] = {
18004 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18005 };
18006
18007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18009 if (SWIG_arg_fail(1)) SWIG_fail;
18010 {
18011 arg2 = wxString_in_helper(obj1);
18012 if (arg2 == NULL) SWIG_fail;
18013 temp2 = true;
18014 }
18015 {
18016 arg3 = wxString_in_helper(obj2);
18017 if (arg3 == NULL) SWIG_fail;
18018 temp3 = true;
18019 }
18020 {
18021 PyThreadState* __tstate = wxPyBeginAllowThreads();
18022 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
18023
18024 wxPyEndAllowThreads(__tstate);
18025 if (PyErr_Occurred()) SWIG_fail;
18026 }
18027 {
18028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18029 }
18030 {
18031 if (temp2)
18032 delete arg2;
18033 }
18034 {
18035 if (temp3)
18036 delete arg3;
18037 }
18038 return resultobj;
18039 fail:
18040 {
18041 if (temp2)
18042 delete arg2;
18043 }
18044 {
18045 if (temp3)
18046 delete arg3;
18047 }
18048 return NULL;
18049 }
18050
18051
18052 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18053 PyObject *resultobj;
18054 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18055 wxString *arg2 = 0 ;
18056 wxString *arg3 = 0 ;
18057 bool result;
18058 bool temp2 = false ;
18059 bool temp3 = false ;
18060 PyObject * obj0 = 0 ;
18061 PyObject * obj1 = 0 ;
18062 PyObject * obj2 = 0 ;
18063 char *kwnames[] = {
18064 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18065 };
18066
18067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18069 if (SWIG_arg_fail(1)) SWIG_fail;
18070 {
18071 arg2 = wxString_in_helper(obj1);
18072 if (arg2 == NULL) SWIG_fail;
18073 temp2 = true;
18074 }
18075 {
18076 arg3 = wxString_in_helper(obj2);
18077 if (arg3 == NULL) SWIG_fail;
18078 temp3 = true;
18079 }
18080 {
18081 PyThreadState* __tstate = wxPyBeginAllowThreads();
18082 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18083
18084 wxPyEndAllowThreads(__tstate);
18085 if (PyErr_Occurred()) SWIG_fail;
18086 }
18087 {
18088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18089 }
18090 {
18091 if (temp2)
18092 delete arg2;
18093 }
18094 {
18095 if (temp3)
18096 delete arg3;
18097 }
18098 return resultobj;
18099 fail:
18100 {
18101 if (temp2)
18102 delete arg2;
18103 }
18104 {
18105 if (temp3)
18106 delete arg3;
18107 }
18108 return NULL;
18109 }
18110
18111
18112 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18113 PyObject *resultobj;
18114 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18115 wxString *arg2 = 0 ;
18116 bool arg3 = (bool) true ;
18117 bool result;
18118 bool temp2 = false ;
18119 PyObject * obj0 = 0 ;
18120 PyObject * obj1 = 0 ;
18121 PyObject * obj2 = 0 ;
18122 char *kwnames[] = {
18123 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18124 };
18125
18126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = wxString_in_helper(obj1);
18131 if (arg2 == NULL) SWIG_fail;
18132 temp2 = true;
18133 }
18134 if (obj2) {
18135 {
18136 arg3 = (bool)(SWIG_As_bool(obj2));
18137 if (SWIG_arg_fail(3)) SWIG_fail;
18138 }
18139 }
18140 {
18141 PyThreadState* __tstate = wxPyBeginAllowThreads();
18142 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18143
18144 wxPyEndAllowThreads(__tstate);
18145 if (PyErr_Occurred()) SWIG_fail;
18146 }
18147 {
18148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18149 }
18150 {
18151 if (temp2)
18152 delete arg2;
18153 }
18154 return resultobj;
18155 fail:
18156 {
18157 if (temp2)
18158 delete arg2;
18159 }
18160 return NULL;
18161 }
18162
18163
18164 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18165 PyObject *resultobj;
18166 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18167 wxString *arg2 = 0 ;
18168 bool result;
18169 bool temp2 = false ;
18170 PyObject * obj0 = 0 ;
18171 PyObject * obj1 = 0 ;
18172 char *kwnames[] = {
18173 (char *) "self",(char *) "key", NULL
18174 };
18175
18176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18178 if (SWIG_arg_fail(1)) SWIG_fail;
18179 {
18180 arg2 = wxString_in_helper(obj1);
18181 if (arg2 == NULL) SWIG_fail;
18182 temp2 = true;
18183 }
18184 {
18185 PyThreadState* __tstate = wxPyBeginAllowThreads();
18186 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18187
18188 wxPyEndAllowThreads(__tstate);
18189 if (PyErr_Occurred()) SWIG_fail;
18190 }
18191 {
18192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18193 }
18194 {
18195 if (temp2)
18196 delete arg2;
18197 }
18198 return resultobj;
18199 fail:
18200 {
18201 if (temp2)
18202 delete arg2;
18203 }
18204 return NULL;
18205 }
18206
18207
18208 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18209 PyObject *resultobj;
18210 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18211 bool result;
18212 PyObject * obj0 = 0 ;
18213 char *kwnames[] = {
18214 (char *) "self", NULL
18215 };
18216
18217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18219 if (SWIG_arg_fail(1)) SWIG_fail;
18220 {
18221 PyThreadState* __tstate = wxPyBeginAllowThreads();
18222 result = (bool)(arg1)->DeleteAll();
18223
18224 wxPyEndAllowThreads(__tstate);
18225 if (PyErr_Occurred()) SWIG_fail;
18226 }
18227 {
18228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18229 }
18230 return resultobj;
18231 fail:
18232 return NULL;
18233 }
18234
18235
18236 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18237 PyObject *resultobj;
18238 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18239 bool arg2 = (bool) true ;
18240 PyObject * obj0 = 0 ;
18241 PyObject * obj1 = 0 ;
18242 char *kwnames[] = {
18243 (char *) "self",(char *) "doIt", NULL
18244 };
18245
18246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18248 if (SWIG_arg_fail(1)) SWIG_fail;
18249 if (obj1) {
18250 {
18251 arg2 = (bool)(SWIG_As_bool(obj1));
18252 if (SWIG_arg_fail(2)) SWIG_fail;
18253 }
18254 }
18255 {
18256 PyThreadState* __tstate = wxPyBeginAllowThreads();
18257 (arg1)->SetExpandEnvVars(arg2);
18258
18259 wxPyEndAllowThreads(__tstate);
18260 if (PyErr_Occurred()) SWIG_fail;
18261 }
18262 Py_INCREF(Py_None); resultobj = Py_None;
18263 return resultobj;
18264 fail:
18265 return NULL;
18266 }
18267
18268
18269 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18270 PyObject *resultobj;
18271 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18272 bool result;
18273 PyObject * obj0 = 0 ;
18274 char *kwnames[] = {
18275 (char *) "self", NULL
18276 };
18277
18278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18280 if (SWIG_arg_fail(1)) SWIG_fail;
18281 {
18282 PyThreadState* __tstate = wxPyBeginAllowThreads();
18283 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18284
18285 wxPyEndAllowThreads(__tstate);
18286 if (PyErr_Occurred()) SWIG_fail;
18287 }
18288 {
18289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18290 }
18291 return resultobj;
18292 fail:
18293 return NULL;
18294 }
18295
18296
18297 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18298 PyObject *resultobj;
18299 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18300 bool arg2 = (bool) true ;
18301 PyObject * obj0 = 0 ;
18302 PyObject * obj1 = 0 ;
18303 char *kwnames[] = {
18304 (char *) "self",(char *) "doIt", NULL
18305 };
18306
18307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18309 if (SWIG_arg_fail(1)) SWIG_fail;
18310 if (obj1) {
18311 {
18312 arg2 = (bool)(SWIG_As_bool(obj1));
18313 if (SWIG_arg_fail(2)) SWIG_fail;
18314 }
18315 }
18316 {
18317 PyThreadState* __tstate = wxPyBeginAllowThreads();
18318 (arg1)->SetRecordDefaults(arg2);
18319
18320 wxPyEndAllowThreads(__tstate);
18321 if (PyErr_Occurred()) SWIG_fail;
18322 }
18323 Py_INCREF(Py_None); resultobj = Py_None;
18324 return resultobj;
18325 fail:
18326 return NULL;
18327 }
18328
18329
18330 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18331 PyObject *resultobj;
18332 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18333 bool result;
18334 PyObject * obj0 = 0 ;
18335 char *kwnames[] = {
18336 (char *) "self", NULL
18337 };
18338
18339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18341 if (SWIG_arg_fail(1)) SWIG_fail;
18342 {
18343 PyThreadState* __tstate = wxPyBeginAllowThreads();
18344 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18345
18346 wxPyEndAllowThreads(__tstate);
18347 if (PyErr_Occurred()) SWIG_fail;
18348 }
18349 {
18350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18351 }
18352 return resultobj;
18353 fail:
18354 return NULL;
18355 }
18356
18357
18358 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18359 PyObject *resultobj;
18360 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18361 wxString *arg2 = 0 ;
18362 wxString result;
18363 bool temp2 = false ;
18364 PyObject * obj0 = 0 ;
18365 PyObject * obj1 = 0 ;
18366 char *kwnames[] = {
18367 (char *) "self",(char *) "str", NULL
18368 };
18369
18370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18372 if (SWIG_arg_fail(1)) SWIG_fail;
18373 {
18374 arg2 = wxString_in_helper(obj1);
18375 if (arg2 == NULL) SWIG_fail;
18376 temp2 = true;
18377 }
18378 {
18379 PyThreadState* __tstate = wxPyBeginAllowThreads();
18380 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18381
18382 wxPyEndAllowThreads(__tstate);
18383 if (PyErr_Occurred()) SWIG_fail;
18384 }
18385 {
18386 #if wxUSE_UNICODE
18387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18388 #else
18389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18390 #endif
18391 }
18392 {
18393 if (temp2)
18394 delete arg2;
18395 }
18396 return resultobj;
18397 fail:
18398 {
18399 if (temp2)
18400 delete arg2;
18401 }
18402 return NULL;
18403 }
18404
18405
18406 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18407 PyObject *resultobj;
18408 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18409 wxString result;
18410 PyObject * obj0 = 0 ;
18411 char *kwnames[] = {
18412 (char *) "self", NULL
18413 };
18414
18415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18417 if (SWIG_arg_fail(1)) SWIG_fail;
18418 {
18419 PyThreadState* __tstate = wxPyBeginAllowThreads();
18420 result = ((wxConfigBase const *)arg1)->GetAppName();
18421
18422 wxPyEndAllowThreads(__tstate);
18423 if (PyErr_Occurred()) SWIG_fail;
18424 }
18425 {
18426 #if wxUSE_UNICODE
18427 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18428 #else
18429 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18430 #endif
18431 }
18432 return resultobj;
18433 fail:
18434 return NULL;
18435 }
18436
18437
18438 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18439 PyObject *resultobj;
18440 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18441 wxString result;
18442 PyObject * obj0 = 0 ;
18443 char *kwnames[] = {
18444 (char *) "self", NULL
18445 };
18446
18447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18449 if (SWIG_arg_fail(1)) SWIG_fail;
18450 {
18451 PyThreadState* __tstate = wxPyBeginAllowThreads();
18452 result = ((wxConfigBase const *)arg1)->GetVendorName();
18453
18454 wxPyEndAllowThreads(__tstate);
18455 if (PyErr_Occurred()) SWIG_fail;
18456 }
18457 {
18458 #if wxUSE_UNICODE
18459 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18460 #else
18461 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18462 #endif
18463 }
18464 return resultobj;
18465 fail:
18466 return NULL;
18467 }
18468
18469
18470 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18471 PyObject *resultobj;
18472 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18473 wxString *arg2 = 0 ;
18474 bool temp2 = false ;
18475 PyObject * obj0 = 0 ;
18476 PyObject * obj1 = 0 ;
18477 char *kwnames[] = {
18478 (char *) "self",(char *) "appName", NULL
18479 };
18480
18481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18483 if (SWIG_arg_fail(1)) SWIG_fail;
18484 {
18485 arg2 = wxString_in_helper(obj1);
18486 if (arg2 == NULL) SWIG_fail;
18487 temp2 = true;
18488 }
18489 {
18490 PyThreadState* __tstate = wxPyBeginAllowThreads();
18491 (arg1)->SetAppName((wxString const &)*arg2);
18492
18493 wxPyEndAllowThreads(__tstate);
18494 if (PyErr_Occurred()) SWIG_fail;
18495 }
18496 Py_INCREF(Py_None); resultobj = Py_None;
18497 {
18498 if (temp2)
18499 delete arg2;
18500 }
18501 return resultobj;
18502 fail:
18503 {
18504 if (temp2)
18505 delete arg2;
18506 }
18507 return NULL;
18508 }
18509
18510
18511 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18512 PyObject *resultobj;
18513 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18514 wxString *arg2 = 0 ;
18515 bool temp2 = false ;
18516 PyObject * obj0 = 0 ;
18517 PyObject * obj1 = 0 ;
18518 char *kwnames[] = {
18519 (char *) "self",(char *) "vendorName", NULL
18520 };
18521
18522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18524 if (SWIG_arg_fail(1)) SWIG_fail;
18525 {
18526 arg2 = wxString_in_helper(obj1);
18527 if (arg2 == NULL) SWIG_fail;
18528 temp2 = true;
18529 }
18530 {
18531 PyThreadState* __tstate = wxPyBeginAllowThreads();
18532 (arg1)->SetVendorName((wxString const &)*arg2);
18533
18534 wxPyEndAllowThreads(__tstate);
18535 if (PyErr_Occurred()) SWIG_fail;
18536 }
18537 Py_INCREF(Py_None); resultobj = Py_None;
18538 {
18539 if (temp2)
18540 delete arg2;
18541 }
18542 return resultobj;
18543 fail:
18544 {
18545 if (temp2)
18546 delete arg2;
18547 }
18548 return NULL;
18549 }
18550
18551
18552 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18553 PyObject *resultobj;
18554 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18555 long arg2 ;
18556 PyObject * obj0 = 0 ;
18557 PyObject * obj1 = 0 ;
18558 char *kwnames[] = {
18559 (char *) "self",(char *) "style", NULL
18560 };
18561
18562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18564 if (SWIG_arg_fail(1)) SWIG_fail;
18565 {
18566 arg2 = (long)(SWIG_As_long(obj1));
18567 if (SWIG_arg_fail(2)) SWIG_fail;
18568 }
18569 {
18570 PyThreadState* __tstate = wxPyBeginAllowThreads();
18571 (arg1)->SetStyle(arg2);
18572
18573 wxPyEndAllowThreads(__tstate);
18574 if (PyErr_Occurred()) SWIG_fail;
18575 }
18576 Py_INCREF(Py_None); resultobj = Py_None;
18577 return resultobj;
18578 fail:
18579 return NULL;
18580 }
18581
18582
18583 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18584 PyObject *resultobj;
18585 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18586 long result;
18587 PyObject * obj0 = 0 ;
18588 char *kwnames[] = {
18589 (char *) "self", NULL
18590 };
18591
18592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18594 if (SWIG_arg_fail(1)) SWIG_fail;
18595 {
18596 PyThreadState* __tstate = wxPyBeginAllowThreads();
18597 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18598
18599 wxPyEndAllowThreads(__tstate);
18600 if (PyErr_Occurred()) SWIG_fail;
18601 }
18602 {
18603 resultobj = SWIG_From_long((long)(result));
18604 }
18605 return resultobj;
18606 fail:
18607 return NULL;
18608 }
18609
18610
18611 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18612 PyObject *obj;
18613 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18614 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18615 Py_INCREF(obj);
18616 return Py_BuildValue((char *)"");
18617 }
18618 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18619 PyObject *resultobj;
18620 wxString const &arg1_defvalue = wxPyEmptyString ;
18621 wxString *arg1 = (wxString *) &arg1_defvalue ;
18622 wxString const &arg2_defvalue = wxPyEmptyString ;
18623 wxString *arg2 = (wxString *) &arg2_defvalue ;
18624 wxString const &arg3_defvalue = wxPyEmptyString ;
18625 wxString *arg3 = (wxString *) &arg3_defvalue ;
18626 wxString const &arg4_defvalue = wxPyEmptyString ;
18627 wxString *arg4 = (wxString *) &arg4_defvalue ;
18628 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18629 wxConfig *result;
18630 bool temp1 = false ;
18631 bool temp2 = false ;
18632 bool temp3 = false ;
18633 bool temp4 = false ;
18634 PyObject * obj0 = 0 ;
18635 PyObject * obj1 = 0 ;
18636 PyObject * obj2 = 0 ;
18637 PyObject * obj3 = 0 ;
18638 PyObject * obj4 = 0 ;
18639 char *kwnames[] = {
18640 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18641 };
18642
18643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18644 if (obj0) {
18645 {
18646 arg1 = wxString_in_helper(obj0);
18647 if (arg1 == NULL) SWIG_fail;
18648 temp1 = true;
18649 }
18650 }
18651 if (obj1) {
18652 {
18653 arg2 = wxString_in_helper(obj1);
18654 if (arg2 == NULL) SWIG_fail;
18655 temp2 = true;
18656 }
18657 }
18658 if (obj2) {
18659 {
18660 arg3 = wxString_in_helper(obj2);
18661 if (arg3 == NULL) SWIG_fail;
18662 temp3 = true;
18663 }
18664 }
18665 if (obj3) {
18666 {
18667 arg4 = wxString_in_helper(obj3);
18668 if (arg4 == NULL) SWIG_fail;
18669 temp4 = true;
18670 }
18671 }
18672 if (obj4) {
18673 {
18674 arg5 = (long)(SWIG_As_long(obj4));
18675 if (SWIG_arg_fail(5)) SWIG_fail;
18676 }
18677 }
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18681
18682 wxPyEndAllowThreads(__tstate);
18683 if (PyErr_Occurred()) SWIG_fail;
18684 }
18685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18686 {
18687 if (temp1)
18688 delete arg1;
18689 }
18690 {
18691 if (temp2)
18692 delete arg2;
18693 }
18694 {
18695 if (temp3)
18696 delete arg3;
18697 }
18698 {
18699 if (temp4)
18700 delete arg4;
18701 }
18702 return resultobj;
18703 fail:
18704 {
18705 if (temp1)
18706 delete arg1;
18707 }
18708 {
18709 if (temp2)
18710 delete arg2;
18711 }
18712 {
18713 if (temp3)
18714 delete arg3;
18715 }
18716 {
18717 if (temp4)
18718 delete arg4;
18719 }
18720 return NULL;
18721 }
18722
18723
18724 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18725 PyObject *resultobj;
18726 wxConfig *arg1 = (wxConfig *) 0 ;
18727 PyObject * obj0 = 0 ;
18728 char *kwnames[] = {
18729 (char *) "self", NULL
18730 };
18731
18732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18734 if (SWIG_arg_fail(1)) SWIG_fail;
18735 {
18736 PyThreadState* __tstate = wxPyBeginAllowThreads();
18737 delete arg1;
18738
18739 wxPyEndAllowThreads(__tstate);
18740 if (PyErr_Occurred()) SWIG_fail;
18741 }
18742 Py_INCREF(Py_None); resultobj = Py_None;
18743 return resultobj;
18744 fail:
18745 return NULL;
18746 }
18747
18748
18749 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18750 PyObject *obj;
18751 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18752 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18753 Py_INCREF(obj);
18754 return Py_BuildValue((char *)"");
18755 }
18756 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18757 PyObject *resultobj;
18758 wxString const &arg1_defvalue = wxPyEmptyString ;
18759 wxString *arg1 = (wxString *) &arg1_defvalue ;
18760 wxString const &arg2_defvalue = wxPyEmptyString ;
18761 wxString *arg2 = (wxString *) &arg2_defvalue ;
18762 wxString const &arg3_defvalue = wxPyEmptyString ;
18763 wxString *arg3 = (wxString *) &arg3_defvalue ;
18764 wxString const &arg4_defvalue = wxPyEmptyString ;
18765 wxString *arg4 = (wxString *) &arg4_defvalue ;
18766 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18767 wxFileConfig *result;
18768 bool temp1 = false ;
18769 bool temp2 = false ;
18770 bool temp3 = false ;
18771 bool temp4 = false ;
18772 PyObject * obj0 = 0 ;
18773 PyObject * obj1 = 0 ;
18774 PyObject * obj2 = 0 ;
18775 PyObject * obj3 = 0 ;
18776 PyObject * obj4 = 0 ;
18777 char *kwnames[] = {
18778 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18779 };
18780
18781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18782 if (obj0) {
18783 {
18784 arg1 = wxString_in_helper(obj0);
18785 if (arg1 == NULL) SWIG_fail;
18786 temp1 = true;
18787 }
18788 }
18789 if (obj1) {
18790 {
18791 arg2 = wxString_in_helper(obj1);
18792 if (arg2 == NULL) SWIG_fail;
18793 temp2 = true;
18794 }
18795 }
18796 if (obj2) {
18797 {
18798 arg3 = wxString_in_helper(obj2);
18799 if (arg3 == NULL) SWIG_fail;
18800 temp3 = true;
18801 }
18802 }
18803 if (obj3) {
18804 {
18805 arg4 = wxString_in_helper(obj3);
18806 if (arg4 == NULL) SWIG_fail;
18807 temp4 = true;
18808 }
18809 }
18810 if (obj4) {
18811 {
18812 arg5 = (long)(SWIG_As_long(obj4));
18813 if (SWIG_arg_fail(5)) SWIG_fail;
18814 }
18815 }
18816 {
18817 PyThreadState* __tstate = wxPyBeginAllowThreads();
18818 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18819
18820 wxPyEndAllowThreads(__tstate);
18821 if (PyErr_Occurred()) SWIG_fail;
18822 }
18823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18824 {
18825 if (temp1)
18826 delete arg1;
18827 }
18828 {
18829 if (temp2)
18830 delete arg2;
18831 }
18832 {
18833 if (temp3)
18834 delete arg3;
18835 }
18836 {
18837 if (temp4)
18838 delete arg4;
18839 }
18840 return resultobj;
18841 fail:
18842 {
18843 if (temp1)
18844 delete arg1;
18845 }
18846 {
18847 if (temp2)
18848 delete arg2;
18849 }
18850 {
18851 if (temp3)
18852 delete arg3;
18853 }
18854 {
18855 if (temp4)
18856 delete arg4;
18857 }
18858 return NULL;
18859 }
18860
18861
18862 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18863 PyObject *resultobj;
18864 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18865 PyObject * obj0 = 0 ;
18866 char *kwnames[] = {
18867 (char *) "self", NULL
18868 };
18869
18870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18872 if (SWIG_arg_fail(1)) SWIG_fail;
18873 {
18874 PyThreadState* __tstate = wxPyBeginAllowThreads();
18875 delete arg1;
18876
18877 wxPyEndAllowThreads(__tstate);
18878 if (PyErr_Occurred()) SWIG_fail;
18879 }
18880 Py_INCREF(Py_None); resultobj = Py_None;
18881 return resultobj;
18882 fail:
18883 return NULL;
18884 }
18885
18886
18887 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18888 PyObject *obj;
18889 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18890 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18891 Py_INCREF(obj);
18892 return Py_BuildValue((char *)"");
18893 }
18894 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18895 PyObject *resultobj;
18896 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18897 wxString *arg2 = 0 ;
18898 wxConfigPathChanger *result;
18899 bool temp2 = false ;
18900 PyObject * obj0 = 0 ;
18901 PyObject * obj1 = 0 ;
18902 char *kwnames[] = {
18903 (char *) "config",(char *) "entry", NULL
18904 };
18905
18906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18908 if (SWIG_arg_fail(1)) SWIG_fail;
18909 {
18910 arg2 = wxString_in_helper(obj1);
18911 if (arg2 == NULL) SWIG_fail;
18912 temp2 = true;
18913 }
18914 {
18915 PyThreadState* __tstate = wxPyBeginAllowThreads();
18916 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18917
18918 wxPyEndAllowThreads(__tstate);
18919 if (PyErr_Occurred()) SWIG_fail;
18920 }
18921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18922 {
18923 if (temp2)
18924 delete arg2;
18925 }
18926 return resultobj;
18927 fail:
18928 {
18929 if (temp2)
18930 delete arg2;
18931 }
18932 return NULL;
18933 }
18934
18935
18936 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18937 PyObject *resultobj;
18938 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18939 PyObject * obj0 = 0 ;
18940 char *kwnames[] = {
18941 (char *) "self", NULL
18942 };
18943
18944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18946 if (SWIG_arg_fail(1)) SWIG_fail;
18947 {
18948 PyThreadState* __tstate = wxPyBeginAllowThreads();
18949 delete arg1;
18950
18951 wxPyEndAllowThreads(__tstate);
18952 if (PyErr_Occurred()) SWIG_fail;
18953 }
18954 Py_INCREF(Py_None); resultobj = Py_None;
18955 return resultobj;
18956 fail:
18957 return NULL;
18958 }
18959
18960
18961 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18962 PyObject *resultobj;
18963 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18964 wxString *result;
18965 PyObject * obj0 = 0 ;
18966 char *kwnames[] = {
18967 (char *) "self", NULL
18968 };
18969
18970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18972 if (SWIG_arg_fail(1)) SWIG_fail;
18973 {
18974 PyThreadState* __tstate = wxPyBeginAllowThreads();
18975 {
18976 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18977 result = (wxString *) &_result_ref;
18978 }
18979
18980 wxPyEndAllowThreads(__tstate);
18981 if (PyErr_Occurred()) SWIG_fail;
18982 }
18983 {
18984 #if wxUSE_UNICODE
18985 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18986 #else
18987 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18988 #endif
18989 }
18990 return resultobj;
18991 fail:
18992 return NULL;
18993 }
18994
18995
18996 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18997 PyObject *obj;
18998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18999 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
19000 Py_INCREF(obj);
19001 return Py_BuildValue((char *)"");
19002 }
19003 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19004 PyObject *resultobj;
19005 wxString *arg1 = 0 ;
19006 wxString result;
19007 bool temp1 = false ;
19008 PyObject * obj0 = 0 ;
19009 char *kwnames[] = {
19010 (char *) "sz", NULL
19011 };
19012
19013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
19014 {
19015 arg1 = wxString_in_helper(obj0);
19016 if (arg1 == NULL) SWIG_fail;
19017 temp1 = true;
19018 }
19019 {
19020 PyThreadState* __tstate = wxPyBeginAllowThreads();
19021 result = wxExpandEnvVars((wxString const &)*arg1);
19022
19023 wxPyEndAllowThreads(__tstate);
19024 if (PyErr_Occurred()) SWIG_fail;
19025 }
19026 {
19027 #if wxUSE_UNICODE
19028 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19029 #else
19030 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19031 #endif
19032 }
19033 {
19034 if (temp1)
19035 delete arg1;
19036 }
19037 return resultobj;
19038 fail:
19039 {
19040 if (temp1)
19041 delete arg1;
19042 }
19043 return NULL;
19044 }
19045
19046
19047 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19048 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19049 return 1;
19050 }
19051
19052
19053 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19054 PyObject *pyobj;
19055
19056 {
19057 #if wxUSE_UNICODE
19058 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19059 #else
19060 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19061 #endif
19062 }
19063 return pyobj;
19064 }
19065
19066
19067 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19068 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19069 return 1;
19070 }
19071
19072
19073 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19074 PyObject *pyobj;
19075
19076 {
19077 #if wxUSE_UNICODE
19078 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19079 #else
19080 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19081 #endif
19082 }
19083 return pyobj;
19084 }
19085
19086
19087 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19088 PyObject *resultobj;
19089 wxDateTime::Country arg1 ;
19090 PyObject * obj0 = 0 ;
19091 char *kwnames[] = {
19092 (char *) "country", NULL
19093 };
19094
19095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19096 {
19097 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19098 if (SWIG_arg_fail(1)) SWIG_fail;
19099 }
19100 {
19101 PyThreadState* __tstate = wxPyBeginAllowThreads();
19102 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19103
19104 wxPyEndAllowThreads(__tstate);
19105 if (PyErr_Occurred()) SWIG_fail;
19106 }
19107 Py_INCREF(Py_None); resultobj = Py_None;
19108 return resultobj;
19109 fail:
19110 return NULL;
19111 }
19112
19113
19114 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19115 PyObject *resultobj;
19116 wxDateTime::Country result;
19117 char *kwnames[] = {
19118 NULL
19119 };
19120
19121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19122 {
19123 PyThreadState* __tstate = wxPyBeginAllowThreads();
19124 result = (wxDateTime::Country)wxDateTime::GetCountry();
19125
19126 wxPyEndAllowThreads(__tstate);
19127 if (PyErr_Occurred()) SWIG_fail;
19128 }
19129 resultobj = SWIG_From_int((result));
19130 return resultobj;
19131 fail:
19132 return NULL;
19133 }
19134
19135
19136 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19137 PyObject *resultobj;
19138 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19139 bool result;
19140 PyObject * obj0 = 0 ;
19141 char *kwnames[] = {
19142 (char *) "country", NULL
19143 };
19144
19145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19146 if (obj0) {
19147 {
19148 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19149 if (SWIG_arg_fail(1)) SWIG_fail;
19150 }
19151 }
19152 {
19153 PyThreadState* __tstate = wxPyBeginAllowThreads();
19154 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19155
19156 wxPyEndAllowThreads(__tstate);
19157 if (PyErr_Occurred()) SWIG_fail;
19158 }
19159 {
19160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19161 }
19162 return resultobj;
19163 fail:
19164 return NULL;
19165 }
19166
19167
19168 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19169 PyObject *resultobj;
19170 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19171 int result;
19172 PyObject * obj0 = 0 ;
19173 char *kwnames[] = {
19174 (char *) "cal", NULL
19175 };
19176
19177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19178 if (obj0) {
19179 {
19180 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19181 if (SWIG_arg_fail(1)) SWIG_fail;
19182 }
19183 }
19184 {
19185 PyThreadState* __tstate = wxPyBeginAllowThreads();
19186 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19187
19188 wxPyEndAllowThreads(__tstate);
19189 if (PyErr_Occurred()) SWIG_fail;
19190 }
19191 {
19192 resultobj = SWIG_From_int((int)(result));
19193 }
19194 return resultobj;
19195 fail:
19196 return NULL;
19197 }
19198
19199
19200 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19201 PyObject *resultobj;
19202 int arg1 ;
19203 int result;
19204 PyObject * obj0 = 0 ;
19205 char *kwnames[] = {
19206 (char *) "year", NULL
19207 };
19208
19209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19210 {
19211 arg1 = (int)(SWIG_As_int(obj0));
19212 if (SWIG_arg_fail(1)) SWIG_fail;
19213 }
19214 {
19215 PyThreadState* __tstate = wxPyBeginAllowThreads();
19216 result = (int)wxDateTime::ConvertYearToBC(arg1);
19217
19218 wxPyEndAllowThreads(__tstate);
19219 if (PyErr_Occurred()) SWIG_fail;
19220 }
19221 {
19222 resultobj = SWIG_From_int((int)(result));
19223 }
19224 return resultobj;
19225 fail:
19226 return NULL;
19227 }
19228
19229
19230 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19231 PyObject *resultobj;
19232 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19233 wxDateTime::Month result;
19234 PyObject * obj0 = 0 ;
19235 char *kwnames[] = {
19236 (char *) "cal", NULL
19237 };
19238
19239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19240 if (obj0) {
19241 {
19242 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19243 if (SWIG_arg_fail(1)) SWIG_fail;
19244 }
19245 }
19246 {
19247 PyThreadState* __tstate = wxPyBeginAllowThreads();
19248 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19249
19250 wxPyEndAllowThreads(__tstate);
19251 if (PyErr_Occurred()) SWIG_fail;
19252 }
19253 resultobj = SWIG_From_int((result));
19254 return resultobj;
19255 fail:
19256 return NULL;
19257 }
19258
19259
19260 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19261 PyObject *resultobj;
19262 int arg1 = (int) wxDateTime::Inv_Year ;
19263 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19264 bool result;
19265 PyObject * obj0 = 0 ;
19266 PyObject * obj1 = 0 ;
19267 char *kwnames[] = {
19268 (char *) "year",(char *) "cal", NULL
19269 };
19270
19271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19272 if (obj0) {
19273 {
19274 arg1 = (int)(SWIG_As_int(obj0));
19275 if (SWIG_arg_fail(1)) SWIG_fail;
19276 }
19277 }
19278 if (obj1) {
19279 {
19280 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19281 if (SWIG_arg_fail(2)) SWIG_fail;
19282 }
19283 }
19284 {
19285 PyThreadState* __tstate = wxPyBeginAllowThreads();
19286 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19287
19288 wxPyEndAllowThreads(__tstate);
19289 if (PyErr_Occurred()) SWIG_fail;
19290 }
19291 {
19292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19293 }
19294 return resultobj;
19295 fail:
19296 return NULL;
19297 }
19298
19299
19300 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19301 PyObject *resultobj;
19302 int arg1 = (int) wxDateTime::Inv_Year ;
19303 int result;
19304 PyObject * obj0 = 0 ;
19305 char *kwnames[] = {
19306 (char *) "year", NULL
19307 };
19308
19309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19310 if (obj0) {
19311 {
19312 arg1 = (int)(SWIG_As_int(obj0));
19313 if (SWIG_arg_fail(1)) SWIG_fail;
19314 }
19315 }
19316 {
19317 PyThreadState* __tstate = wxPyBeginAllowThreads();
19318 result = (int)wxDateTime::GetCentury(arg1);
19319
19320 wxPyEndAllowThreads(__tstate);
19321 if (PyErr_Occurred()) SWIG_fail;
19322 }
19323 {
19324 resultobj = SWIG_From_int((int)(result));
19325 }
19326 return resultobj;
19327 fail:
19328 return NULL;
19329 }
19330
19331
19332 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19333 PyObject *resultobj;
19334 int arg1 ;
19335 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19336 int result;
19337 PyObject * obj0 = 0 ;
19338 PyObject * obj1 = 0 ;
19339 char *kwnames[] = {
19340 (char *) "year",(char *) "cal", NULL
19341 };
19342
19343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19344 {
19345 arg1 = (int)(SWIG_As_int(obj0));
19346 if (SWIG_arg_fail(1)) SWIG_fail;
19347 }
19348 if (obj1) {
19349 {
19350 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19351 if (SWIG_arg_fail(2)) SWIG_fail;
19352 }
19353 }
19354 {
19355 PyThreadState* __tstate = wxPyBeginAllowThreads();
19356 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19357
19358 wxPyEndAllowThreads(__tstate);
19359 if (PyErr_Occurred()) SWIG_fail;
19360 }
19361 {
19362 resultobj = SWIG_From_int((int)(result));
19363 }
19364 return resultobj;
19365 fail:
19366 return NULL;
19367 }
19368
19369
19370 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19371 PyObject *resultobj;
19372 wxDateTime::Month arg1 ;
19373 int arg2 = (int) wxDateTime::Inv_Year ;
19374 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19375 int result;
19376 PyObject * obj0 = 0 ;
19377 PyObject * obj1 = 0 ;
19378 PyObject * obj2 = 0 ;
19379 char *kwnames[] = {
19380 (char *) "month",(char *) "year",(char *) "cal", NULL
19381 };
19382
19383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19384 {
19385 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19386 if (SWIG_arg_fail(1)) SWIG_fail;
19387 }
19388 if (obj1) {
19389 {
19390 arg2 = (int)(SWIG_As_int(obj1));
19391 if (SWIG_arg_fail(2)) SWIG_fail;
19392 }
19393 }
19394 if (obj2) {
19395 {
19396 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19397 if (SWIG_arg_fail(3)) SWIG_fail;
19398 }
19399 }
19400 {
19401 PyThreadState* __tstate = wxPyBeginAllowThreads();
19402 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19403
19404 wxPyEndAllowThreads(__tstate);
19405 if (PyErr_Occurred()) SWIG_fail;
19406 }
19407 {
19408 resultobj = SWIG_From_int((int)(result));
19409 }
19410 return resultobj;
19411 fail:
19412 return NULL;
19413 }
19414
19415
19416 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19417 PyObject *resultobj;
19418 wxDateTime::Month arg1 ;
19419 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19420 wxString result;
19421 PyObject * obj0 = 0 ;
19422 PyObject * obj1 = 0 ;
19423 char *kwnames[] = {
19424 (char *) "month",(char *) "flags", NULL
19425 };
19426
19427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19428 {
19429 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19430 if (SWIG_arg_fail(1)) SWIG_fail;
19431 }
19432 if (obj1) {
19433 {
19434 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19435 if (SWIG_arg_fail(2)) SWIG_fail;
19436 }
19437 }
19438 {
19439 PyThreadState* __tstate = wxPyBeginAllowThreads();
19440 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19441
19442 wxPyEndAllowThreads(__tstate);
19443 if (PyErr_Occurred()) SWIG_fail;
19444 }
19445 {
19446 #if wxUSE_UNICODE
19447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19448 #else
19449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19450 #endif
19451 }
19452 return resultobj;
19453 fail:
19454 return NULL;
19455 }
19456
19457
19458 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19459 PyObject *resultobj;
19460 wxDateTime::WeekDay arg1 ;
19461 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19462 wxString result;
19463 PyObject * obj0 = 0 ;
19464 PyObject * obj1 = 0 ;
19465 char *kwnames[] = {
19466 (char *) "weekday",(char *) "flags", NULL
19467 };
19468
19469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19470 {
19471 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19472 if (SWIG_arg_fail(1)) SWIG_fail;
19473 }
19474 if (obj1) {
19475 {
19476 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19477 if (SWIG_arg_fail(2)) SWIG_fail;
19478 }
19479 }
19480 {
19481 PyThreadState* __tstate = wxPyBeginAllowThreads();
19482 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19483
19484 wxPyEndAllowThreads(__tstate);
19485 if (PyErr_Occurred()) SWIG_fail;
19486 }
19487 {
19488 #if wxUSE_UNICODE
19489 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19490 #else
19491 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19492 #endif
19493 }
19494 return resultobj;
19495 fail:
19496 return NULL;
19497 }
19498
19499
19500 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19501 PyObject *resultobj;
19502 PyObject *result;
19503 char *kwnames[] = {
19504 NULL
19505 };
19506
19507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19508 {
19509 PyThreadState* __tstate = wxPyBeginAllowThreads();
19510 result = (PyObject *)DateTime_GetAmPmStrings();
19511
19512 wxPyEndAllowThreads(__tstate);
19513 if (PyErr_Occurred()) SWIG_fail;
19514 }
19515 resultobj = result;
19516 return resultobj;
19517 fail:
19518 return NULL;
19519 }
19520
19521
19522 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19523 PyObject *resultobj;
19524 int arg1 = (int) wxDateTime::Inv_Year ;
19525 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19526 bool result;
19527 PyObject * obj0 = 0 ;
19528 PyObject * obj1 = 0 ;
19529 char *kwnames[] = {
19530 (char *) "year",(char *) "country", NULL
19531 };
19532
19533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19534 if (obj0) {
19535 {
19536 arg1 = (int)(SWIG_As_int(obj0));
19537 if (SWIG_arg_fail(1)) SWIG_fail;
19538 }
19539 }
19540 if (obj1) {
19541 {
19542 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19543 if (SWIG_arg_fail(2)) SWIG_fail;
19544 }
19545 }
19546 {
19547 PyThreadState* __tstate = wxPyBeginAllowThreads();
19548 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19549
19550 wxPyEndAllowThreads(__tstate);
19551 if (PyErr_Occurred()) SWIG_fail;
19552 }
19553 {
19554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19555 }
19556 return resultobj;
19557 fail:
19558 return NULL;
19559 }
19560
19561
19562 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19563 PyObject *resultobj;
19564 int arg1 = (int) wxDateTime::Inv_Year ;
19565 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19566 wxDateTime result;
19567 PyObject * obj0 = 0 ;
19568 PyObject * obj1 = 0 ;
19569 char *kwnames[] = {
19570 (char *) "year",(char *) "country", NULL
19571 };
19572
19573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19574 if (obj0) {
19575 {
19576 arg1 = (int)(SWIG_As_int(obj0));
19577 if (SWIG_arg_fail(1)) SWIG_fail;
19578 }
19579 }
19580 if (obj1) {
19581 {
19582 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19583 if (SWIG_arg_fail(2)) SWIG_fail;
19584 }
19585 }
19586 {
19587 PyThreadState* __tstate = wxPyBeginAllowThreads();
19588 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19589
19590 wxPyEndAllowThreads(__tstate);
19591 if (PyErr_Occurred()) SWIG_fail;
19592 }
19593 {
19594 wxDateTime * resultptr;
19595 resultptr = new wxDateTime((wxDateTime &)(result));
19596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19597 }
19598 return resultobj;
19599 fail:
19600 return NULL;
19601 }
19602
19603
19604 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19605 PyObject *resultobj;
19606 int arg1 = (int) wxDateTime::Inv_Year ;
19607 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19608 wxDateTime result;
19609 PyObject * obj0 = 0 ;
19610 PyObject * obj1 = 0 ;
19611 char *kwnames[] = {
19612 (char *) "year",(char *) "country", NULL
19613 };
19614
19615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19616 if (obj0) {
19617 {
19618 arg1 = (int)(SWIG_As_int(obj0));
19619 if (SWIG_arg_fail(1)) SWIG_fail;
19620 }
19621 }
19622 if (obj1) {
19623 {
19624 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19625 if (SWIG_arg_fail(2)) SWIG_fail;
19626 }
19627 }
19628 {
19629 PyThreadState* __tstate = wxPyBeginAllowThreads();
19630 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19631
19632 wxPyEndAllowThreads(__tstate);
19633 if (PyErr_Occurred()) SWIG_fail;
19634 }
19635 {
19636 wxDateTime * resultptr;
19637 resultptr = new wxDateTime((wxDateTime &)(result));
19638 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19639 }
19640 return resultobj;
19641 fail:
19642 return NULL;
19643 }
19644
19645
19646 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19647 PyObject *resultobj;
19648 wxDateTime result;
19649 char *kwnames[] = {
19650 NULL
19651 };
19652
19653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19654 {
19655 PyThreadState* __tstate = wxPyBeginAllowThreads();
19656 result = wxDateTime::Now();
19657
19658 wxPyEndAllowThreads(__tstate);
19659 if (PyErr_Occurred()) SWIG_fail;
19660 }
19661 {
19662 wxDateTime * resultptr;
19663 resultptr = new wxDateTime((wxDateTime &)(result));
19664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19665 }
19666 return resultobj;
19667 fail:
19668 return NULL;
19669 }
19670
19671
19672 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19673 PyObject *resultobj;
19674 wxDateTime result;
19675 char *kwnames[] = {
19676 NULL
19677 };
19678
19679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19680 {
19681 PyThreadState* __tstate = wxPyBeginAllowThreads();
19682 result = wxDateTime::UNow();
19683
19684 wxPyEndAllowThreads(__tstate);
19685 if (PyErr_Occurred()) SWIG_fail;
19686 }
19687 {
19688 wxDateTime * resultptr;
19689 resultptr = new wxDateTime((wxDateTime &)(result));
19690 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19691 }
19692 return resultobj;
19693 fail:
19694 return NULL;
19695 }
19696
19697
19698 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19699 PyObject *resultobj;
19700 wxDateTime result;
19701 char *kwnames[] = {
19702 NULL
19703 };
19704
19705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19706 {
19707 PyThreadState* __tstate = wxPyBeginAllowThreads();
19708 result = wxDateTime::Today();
19709
19710 wxPyEndAllowThreads(__tstate);
19711 if (PyErr_Occurred()) SWIG_fail;
19712 }
19713 {
19714 wxDateTime * resultptr;
19715 resultptr = new wxDateTime((wxDateTime &)(result));
19716 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19717 }
19718 return resultobj;
19719 fail:
19720 return NULL;
19721 }
19722
19723
19724 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19725 PyObject *resultobj;
19726 wxDateTime *result;
19727 char *kwnames[] = {
19728 NULL
19729 };
19730
19731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19732 {
19733 PyThreadState* __tstate = wxPyBeginAllowThreads();
19734 result = (wxDateTime *)new wxDateTime();
19735
19736 wxPyEndAllowThreads(__tstate);
19737 if (PyErr_Occurred()) SWIG_fail;
19738 }
19739 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19740 return resultobj;
19741 fail:
19742 return NULL;
19743 }
19744
19745
19746 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19747 PyObject *resultobj;
19748 time_t arg1 ;
19749 wxDateTime *result;
19750 PyObject * obj0 = 0 ;
19751 char *kwnames[] = {
19752 (char *) "timet", NULL
19753 };
19754
19755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19756 {
19757 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19758 if (SWIG_arg_fail(1)) SWIG_fail;
19759 }
19760 {
19761 PyThreadState* __tstate = wxPyBeginAllowThreads();
19762 result = (wxDateTime *)new wxDateTime(arg1);
19763
19764 wxPyEndAllowThreads(__tstate);
19765 if (PyErr_Occurred()) SWIG_fail;
19766 }
19767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19768 return resultobj;
19769 fail:
19770 return NULL;
19771 }
19772
19773
19774 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19775 PyObject *resultobj;
19776 double arg1 ;
19777 wxDateTime *result;
19778 PyObject * obj0 = 0 ;
19779 char *kwnames[] = {
19780 (char *) "jdn", NULL
19781 };
19782
19783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19784 {
19785 arg1 = (double)(SWIG_As_double(obj0));
19786 if (SWIG_arg_fail(1)) SWIG_fail;
19787 }
19788 {
19789 PyThreadState* __tstate = wxPyBeginAllowThreads();
19790 result = (wxDateTime *)new wxDateTime(arg1);
19791
19792 wxPyEndAllowThreads(__tstate);
19793 if (PyErr_Occurred()) SWIG_fail;
19794 }
19795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19796 return resultobj;
19797 fail:
19798 return NULL;
19799 }
19800
19801
19802 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19803 PyObject *resultobj;
19804 int arg1 ;
19805 int arg2 = (int) 0 ;
19806 int arg3 = (int) 0 ;
19807 int arg4 = (int) 0 ;
19808 wxDateTime *result;
19809 PyObject * obj0 = 0 ;
19810 PyObject * obj1 = 0 ;
19811 PyObject * obj2 = 0 ;
19812 PyObject * obj3 = 0 ;
19813 char *kwnames[] = {
19814 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19815 };
19816
19817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19818 {
19819 arg1 = (int)(SWIG_As_int(obj0));
19820 if (SWIG_arg_fail(1)) SWIG_fail;
19821 }
19822 if (obj1) {
19823 {
19824 arg2 = (int)(SWIG_As_int(obj1));
19825 if (SWIG_arg_fail(2)) SWIG_fail;
19826 }
19827 }
19828 if (obj2) {
19829 {
19830 arg3 = (int)(SWIG_As_int(obj2));
19831 if (SWIG_arg_fail(3)) SWIG_fail;
19832 }
19833 }
19834 if (obj3) {
19835 {
19836 arg4 = (int)(SWIG_As_int(obj3));
19837 if (SWIG_arg_fail(4)) SWIG_fail;
19838 }
19839 }
19840 {
19841 PyThreadState* __tstate = wxPyBeginAllowThreads();
19842 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19843
19844 wxPyEndAllowThreads(__tstate);
19845 if (PyErr_Occurred()) SWIG_fail;
19846 }
19847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19848 return resultobj;
19849 fail:
19850 return NULL;
19851 }
19852
19853
19854 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19855 PyObject *resultobj;
19856 int arg1 ;
19857 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19858 int arg3 = (int) wxDateTime::Inv_Year ;
19859 int arg4 = (int) 0 ;
19860 int arg5 = (int) 0 ;
19861 int arg6 = (int) 0 ;
19862 int arg7 = (int) 0 ;
19863 wxDateTime *result;
19864 PyObject * obj0 = 0 ;
19865 PyObject * obj1 = 0 ;
19866 PyObject * obj2 = 0 ;
19867 PyObject * obj3 = 0 ;
19868 PyObject * obj4 = 0 ;
19869 PyObject * obj5 = 0 ;
19870 PyObject * obj6 = 0 ;
19871 char *kwnames[] = {
19872 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19873 };
19874
19875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19876 {
19877 arg1 = (int)(SWIG_As_int(obj0));
19878 if (SWIG_arg_fail(1)) SWIG_fail;
19879 }
19880 if (obj1) {
19881 {
19882 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19883 if (SWIG_arg_fail(2)) SWIG_fail;
19884 }
19885 }
19886 if (obj2) {
19887 {
19888 arg3 = (int)(SWIG_As_int(obj2));
19889 if (SWIG_arg_fail(3)) SWIG_fail;
19890 }
19891 }
19892 if (obj3) {
19893 {
19894 arg4 = (int)(SWIG_As_int(obj3));
19895 if (SWIG_arg_fail(4)) SWIG_fail;
19896 }
19897 }
19898 if (obj4) {
19899 {
19900 arg5 = (int)(SWIG_As_int(obj4));
19901 if (SWIG_arg_fail(5)) SWIG_fail;
19902 }
19903 }
19904 if (obj5) {
19905 {
19906 arg6 = (int)(SWIG_As_int(obj5));
19907 if (SWIG_arg_fail(6)) SWIG_fail;
19908 }
19909 }
19910 if (obj6) {
19911 {
19912 arg7 = (int)(SWIG_As_int(obj6));
19913 if (SWIG_arg_fail(7)) SWIG_fail;
19914 }
19915 }
19916 {
19917 PyThreadState* __tstate = wxPyBeginAllowThreads();
19918 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19919
19920 wxPyEndAllowThreads(__tstate);
19921 if (PyErr_Occurred()) SWIG_fail;
19922 }
19923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19924 return resultobj;
19925 fail:
19926 return NULL;
19927 }
19928
19929
19930 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19931 PyObject *resultobj;
19932 wxDateTime *arg1 = (wxDateTime *) 0 ;
19933 PyObject * obj0 = 0 ;
19934 char *kwnames[] = {
19935 (char *) "self", NULL
19936 };
19937
19938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19940 if (SWIG_arg_fail(1)) SWIG_fail;
19941 {
19942 PyThreadState* __tstate = wxPyBeginAllowThreads();
19943 delete arg1;
19944
19945 wxPyEndAllowThreads(__tstate);
19946 if (PyErr_Occurred()) SWIG_fail;
19947 }
19948 Py_INCREF(Py_None); resultobj = Py_None;
19949 return resultobj;
19950 fail:
19951 return NULL;
19952 }
19953
19954
19955 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19956 PyObject *resultobj;
19957 wxDateTime *arg1 = (wxDateTime *) 0 ;
19958 wxDateTime *result;
19959 PyObject * obj0 = 0 ;
19960 char *kwnames[] = {
19961 (char *) "self", NULL
19962 };
19963
19964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19966 if (SWIG_arg_fail(1)) SWIG_fail;
19967 {
19968 PyThreadState* __tstate = wxPyBeginAllowThreads();
19969 {
19970 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19971 result = (wxDateTime *) &_result_ref;
19972 }
19973
19974 wxPyEndAllowThreads(__tstate);
19975 if (PyErr_Occurred()) SWIG_fail;
19976 }
19977 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19978 return resultobj;
19979 fail:
19980 return NULL;
19981 }
19982
19983
19984 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19985 PyObject *resultobj;
19986 wxDateTime *arg1 = (wxDateTime *) 0 ;
19987 time_t arg2 ;
19988 wxDateTime *result;
19989 PyObject * obj0 = 0 ;
19990 PyObject * obj1 = 0 ;
19991 char *kwnames[] = {
19992 (char *) "self",(char *) "timet", NULL
19993 };
19994
19995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19997 if (SWIG_arg_fail(1)) SWIG_fail;
19998 {
19999 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
20000 if (SWIG_arg_fail(2)) SWIG_fail;
20001 }
20002 {
20003 PyThreadState* __tstate = wxPyBeginAllowThreads();
20004 {
20005 wxDateTime &_result_ref = (arg1)->Set(arg2);
20006 result = (wxDateTime *) &_result_ref;
20007 }
20008
20009 wxPyEndAllowThreads(__tstate);
20010 if (PyErr_Occurred()) SWIG_fail;
20011 }
20012 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20013 return resultobj;
20014 fail:
20015 return NULL;
20016 }
20017
20018
20019 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20020 PyObject *resultobj;
20021 wxDateTime *arg1 = (wxDateTime *) 0 ;
20022 double arg2 ;
20023 wxDateTime *result;
20024 PyObject * obj0 = 0 ;
20025 PyObject * obj1 = 0 ;
20026 char *kwnames[] = {
20027 (char *) "self",(char *) "jdn", NULL
20028 };
20029
20030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
20031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20032 if (SWIG_arg_fail(1)) SWIG_fail;
20033 {
20034 arg2 = (double)(SWIG_As_double(obj1));
20035 if (SWIG_arg_fail(2)) SWIG_fail;
20036 }
20037 {
20038 PyThreadState* __tstate = wxPyBeginAllowThreads();
20039 {
20040 wxDateTime &_result_ref = (arg1)->Set(arg2);
20041 result = (wxDateTime *) &_result_ref;
20042 }
20043
20044 wxPyEndAllowThreads(__tstate);
20045 if (PyErr_Occurred()) SWIG_fail;
20046 }
20047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20048 return resultobj;
20049 fail:
20050 return NULL;
20051 }
20052
20053
20054 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20055 PyObject *resultobj;
20056 wxDateTime *arg1 = (wxDateTime *) 0 ;
20057 int arg2 ;
20058 int arg3 = (int) 0 ;
20059 int arg4 = (int) 0 ;
20060 int arg5 = (int) 0 ;
20061 wxDateTime *result;
20062 PyObject * obj0 = 0 ;
20063 PyObject * obj1 = 0 ;
20064 PyObject * obj2 = 0 ;
20065 PyObject * obj3 = 0 ;
20066 PyObject * obj4 = 0 ;
20067 char *kwnames[] = {
20068 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20069 };
20070
20071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20073 if (SWIG_arg_fail(1)) SWIG_fail;
20074 {
20075 arg2 = (int)(SWIG_As_int(obj1));
20076 if (SWIG_arg_fail(2)) SWIG_fail;
20077 }
20078 if (obj2) {
20079 {
20080 arg3 = (int)(SWIG_As_int(obj2));
20081 if (SWIG_arg_fail(3)) SWIG_fail;
20082 }
20083 }
20084 if (obj3) {
20085 {
20086 arg4 = (int)(SWIG_As_int(obj3));
20087 if (SWIG_arg_fail(4)) SWIG_fail;
20088 }
20089 }
20090 if (obj4) {
20091 {
20092 arg5 = (int)(SWIG_As_int(obj4));
20093 if (SWIG_arg_fail(5)) SWIG_fail;
20094 }
20095 }
20096 {
20097 PyThreadState* __tstate = wxPyBeginAllowThreads();
20098 {
20099 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20100 result = (wxDateTime *) &_result_ref;
20101 }
20102
20103 wxPyEndAllowThreads(__tstate);
20104 if (PyErr_Occurred()) SWIG_fail;
20105 }
20106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20107 return resultobj;
20108 fail:
20109 return NULL;
20110 }
20111
20112
20113 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20114 PyObject *resultobj;
20115 wxDateTime *arg1 = (wxDateTime *) 0 ;
20116 int arg2 ;
20117 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20118 int arg4 = (int) wxDateTime::Inv_Year ;
20119 int arg5 = (int) 0 ;
20120 int arg6 = (int) 0 ;
20121 int arg7 = (int) 0 ;
20122 int arg8 = (int) 0 ;
20123 wxDateTime *result;
20124 PyObject * obj0 = 0 ;
20125 PyObject * obj1 = 0 ;
20126 PyObject * obj2 = 0 ;
20127 PyObject * obj3 = 0 ;
20128 PyObject * obj4 = 0 ;
20129 PyObject * obj5 = 0 ;
20130 PyObject * obj6 = 0 ;
20131 PyObject * obj7 = 0 ;
20132 char *kwnames[] = {
20133 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20134 };
20135
20136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20138 if (SWIG_arg_fail(1)) SWIG_fail;
20139 {
20140 arg2 = (int)(SWIG_As_int(obj1));
20141 if (SWIG_arg_fail(2)) SWIG_fail;
20142 }
20143 if (obj2) {
20144 {
20145 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20146 if (SWIG_arg_fail(3)) SWIG_fail;
20147 }
20148 }
20149 if (obj3) {
20150 {
20151 arg4 = (int)(SWIG_As_int(obj3));
20152 if (SWIG_arg_fail(4)) SWIG_fail;
20153 }
20154 }
20155 if (obj4) {
20156 {
20157 arg5 = (int)(SWIG_As_int(obj4));
20158 if (SWIG_arg_fail(5)) SWIG_fail;
20159 }
20160 }
20161 if (obj5) {
20162 {
20163 arg6 = (int)(SWIG_As_int(obj5));
20164 if (SWIG_arg_fail(6)) SWIG_fail;
20165 }
20166 }
20167 if (obj6) {
20168 {
20169 arg7 = (int)(SWIG_As_int(obj6));
20170 if (SWIG_arg_fail(7)) SWIG_fail;
20171 }
20172 }
20173 if (obj7) {
20174 {
20175 arg8 = (int)(SWIG_As_int(obj7));
20176 if (SWIG_arg_fail(8)) SWIG_fail;
20177 }
20178 }
20179 {
20180 PyThreadState* __tstate = wxPyBeginAllowThreads();
20181 {
20182 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20183 result = (wxDateTime *) &_result_ref;
20184 }
20185
20186 wxPyEndAllowThreads(__tstate);
20187 if (PyErr_Occurred()) SWIG_fail;
20188 }
20189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20190 return resultobj;
20191 fail:
20192 return NULL;
20193 }
20194
20195
20196 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20197 PyObject *resultobj;
20198 wxDateTime *arg1 = (wxDateTime *) 0 ;
20199 wxDateTime *result;
20200 PyObject * obj0 = 0 ;
20201 char *kwnames[] = {
20202 (char *) "self", NULL
20203 };
20204
20205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20207 if (SWIG_arg_fail(1)) SWIG_fail;
20208 {
20209 PyThreadState* __tstate = wxPyBeginAllowThreads();
20210 {
20211 wxDateTime &_result_ref = (arg1)->ResetTime();
20212 result = (wxDateTime *) &_result_ref;
20213 }
20214
20215 wxPyEndAllowThreads(__tstate);
20216 if (PyErr_Occurred()) SWIG_fail;
20217 }
20218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20219 return resultobj;
20220 fail:
20221 return NULL;
20222 }
20223
20224
20225 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20226 PyObject *resultobj;
20227 wxDateTime *arg1 = (wxDateTime *) 0 ;
20228 int arg2 ;
20229 wxDateTime *result;
20230 PyObject * obj0 = 0 ;
20231 PyObject * obj1 = 0 ;
20232 char *kwnames[] = {
20233 (char *) "self",(char *) "year", NULL
20234 };
20235
20236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20238 if (SWIG_arg_fail(1)) SWIG_fail;
20239 {
20240 arg2 = (int)(SWIG_As_int(obj1));
20241 if (SWIG_arg_fail(2)) SWIG_fail;
20242 }
20243 {
20244 PyThreadState* __tstate = wxPyBeginAllowThreads();
20245 {
20246 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20247 result = (wxDateTime *) &_result_ref;
20248 }
20249
20250 wxPyEndAllowThreads(__tstate);
20251 if (PyErr_Occurred()) SWIG_fail;
20252 }
20253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20254 return resultobj;
20255 fail:
20256 return NULL;
20257 }
20258
20259
20260 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20261 PyObject *resultobj;
20262 wxDateTime *arg1 = (wxDateTime *) 0 ;
20263 wxDateTime::Month arg2 ;
20264 wxDateTime *result;
20265 PyObject * obj0 = 0 ;
20266 PyObject * obj1 = 0 ;
20267 char *kwnames[] = {
20268 (char *) "self",(char *) "month", NULL
20269 };
20270
20271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20273 if (SWIG_arg_fail(1)) SWIG_fail;
20274 {
20275 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20276 if (SWIG_arg_fail(2)) SWIG_fail;
20277 }
20278 {
20279 PyThreadState* __tstate = wxPyBeginAllowThreads();
20280 {
20281 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20282 result = (wxDateTime *) &_result_ref;
20283 }
20284
20285 wxPyEndAllowThreads(__tstate);
20286 if (PyErr_Occurred()) SWIG_fail;
20287 }
20288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20289 return resultobj;
20290 fail:
20291 return NULL;
20292 }
20293
20294
20295 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20296 PyObject *resultobj;
20297 wxDateTime *arg1 = (wxDateTime *) 0 ;
20298 int arg2 ;
20299 wxDateTime *result;
20300 PyObject * obj0 = 0 ;
20301 PyObject * obj1 = 0 ;
20302 char *kwnames[] = {
20303 (char *) "self",(char *) "day", NULL
20304 };
20305
20306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20308 if (SWIG_arg_fail(1)) SWIG_fail;
20309 {
20310 arg2 = (int)(SWIG_As_int(obj1));
20311 if (SWIG_arg_fail(2)) SWIG_fail;
20312 }
20313 {
20314 PyThreadState* __tstate = wxPyBeginAllowThreads();
20315 {
20316 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20317 result = (wxDateTime *) &_result_ref;
20318 }
20319
20320 wxPyEndAllowThreads(__tstate);
20321 if (PyErr_Occurred()) SWIG_fail;
20322 }
20323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20324 return resultobj;
20325 fail:
20326 return NULL;
20327 }
20328
20329
20330 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20331 PyObject *resultobj;
20332 wxDateTime *arg1 = (wxDateTime *) 0 ;
20333 int arg2 ;
20334 wxDateTime *result;
20335 PyObject * obj0 = 0 ;
20336 PyObject * obj1 = 0 ;
20337 char *kwnames[] = {
20338 (char *) "self",(char *) "hour", NULL
20339 };
20340
20341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20343 if (SWIG_arg_fail(1)) SWIG_fail;
20344 {
20345 arg2 = (int)(SWIG_As_int(obj1));
20346 if (SWIG_arg_fail(2)) SWIG_fail;
20347 }
20348 {
20349 PyThreadState* __tstate = wxPyBeginAllowThreads();
20350 {
20351 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20352 result = (wxDateTime *) &_result_ref;
20353 }
20354
20355 wxPyEndAllowThreads(__tstate);
20356 if (PyErr_Occurred()) SWIG_fail;
20357 }
20358 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20359 return resultobj;
20360 fail:
20361 return NULL;
20362 }
20363
20364
20365 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20366 PyObject *resultobj;
20367 wxDateTime *arg1 = (wxDateTime *) 0 ;
20368 int arg2 ;
20369 wxDateTime *result;
20370 PyObject * obj0 = 0 ;
20371 PyObject * obj1 = 0 ;
20372 char *kwnames[] = {
20373 (char *) "self",(char *) "minute", NULL
20374 };
20375
20376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20378 if (SWIG_arg_fail(1)) SWIG_fail;
20379 {
20380 arg2 = (int)(SWIG_As_int(obj1));
20381 if (SWIG_arg_fail(2)) SWIG_fail;
20382 }
20383 {
20384 PyThreadState* __tstate = wxPyBeginAllowThreads();
20385 {
20386 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20387 result = (wxDateTime *) &_result_ref;
20388 }
20389
20390 wxPyEndAllowThreads(__tstate);
20391 if (PyErr_Occurred()) SWIG_fail;
20392 }
20393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20394 return resultobj;
20395 fail:
20396 return NULL;
20397 }
20398
20399
20400 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20401 PyObject *resultobj;
20402 wxDateTime *arg1 = (wxDateTime *) 0 ;
20403 int arg2 ;
20404 wxDateTime *result;
20405 PyObject * obj0 = 0 ;
20406 PyObject * obj1 = 0 ;
20407 char *kwnames[] = {
20408 (char *) "self",(char *) "second", NULL
20409 };
20410
20411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20413 if (SWIG_arg_fail(1)) SWIG_fail;
20414 {
20415 arg2 = (int)(SWIG_As_int(obj1));
20416 if (SWIG_arg_fail(2)) SWIG_fail;
20417 }
20418 {
20419 PyThreadState* __tstate = wxPyBeginAllowThreads();
20420 {
20421 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20422 result = (wxDateTime *) &_result_ref;
20423 }
20424
20425 wxPyEndAllowThreads(__tstate);
20426 if (PyErr_Occurred()) SWIG_fail;
20427 }
20428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20429 return resultobj;
20430 fail:
20431 return NULL;
20432 }
20433
20434
20435 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20436 PyObject *resultobj;
20437 wxDateTime *arg1 = (wxDateTime *) 0 ;
20438 int arg2 ;
20439 wxDateTime *result;
20440 PyObject * obj0 = 0 ;
20441 PyObject * obj1 = 0 ;
20442 char *kwnames[] = {
20443 (char *) "self",(char *) "millisecond", NULL
20444 };
20445
20446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20448 if (SWIG_arg_fail(1)) SWIG_fail;
20449 {
20450 arg2 = (int)(SWIG_As_int(obj1));
20451 if (SWIG_arg_fail(2)) SWIG_fail;
20452 }
20453 {
20454 PyThreadState* __tstate = wxPyBeginAllowThreads();
20455 {
20456 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20457 result = (wxDateTime *) &_result_ref;
20458 }
20459
20460 wxPyEndAllowThreads(__tstate);
20461 if (PyErr_Occurred()) SWIG_fail;
20462 }
20463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20464 return resultobj;
20465 fail:
20466 return NULL;
20467 }
20468
20469
20470 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20471 PyObject *resultobj;
20472 wxDateTime *arg1 = (wxDateTime *) 0 ;
20473 wxDateTime::WeekDay arg2 ;
20474 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20475 wxDateTime *result;
20476 PyObject * obj0 = 0 ;
20477 PyObject * obj1 = 0 ;
20478 PyObject * obj2 = 0 ;
20479 char *kwnames[] = {
20480 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20481 };
20482
20483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20485 if (SWIG_arg_fail(1)) SWIG_fail;
20486 {
20487 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20488 if (SWIG_arg_fail(2)) SWIG_fail;
20489 }
20490 if (obj2) {
20491 {
20492 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20493 if (SWIG_arg_fail(3)) SWIG_fail;
20494 }
20495 }
20496 {
20497 PyThreadState* __tstate = wxPyBeginAllowThreads();
20498 {
20499 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20500 result = (wxDateTime *) &_result_ref;
20501 }
20502
20503 wxPyEndAllowThreads(__tstate);
20504 if (PyErr_Occurred()) SWIG_fail;
20505 }
20506 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20507 return resultobj;
20508 fail:
20509 return NULL;
20510 }
20511
20512
20513 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20514 PyObject *resultobj;
20515 wxDateTime *arg1 = (wxDateTime *) 0 ;
20516 wxDateTime::WeekDay arg2 ;
20517 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20518 wxDateTime result;
20519 PyObject * obj0 = 0 ;
20520 PyObject * obj1 = 0 ;
20521 PyObject * obj2 = 0 ;
20522 char *kwnames[] = {
20523 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20524 };
20525
20526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20528 if (SWIG_arg_fail(1)) SWIG_fail;
20529 {
20530 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20531 if (SWIG_arg_fail(2)) SWIG_fail;
20532 }
20533 if (obj2) {
20534 {
20535 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20536 if (SWIG_arg_fail(3)) SWIG_fail;
20537 }
20538 }
20539 {
20540 PyThreadState* __tstate = wxPyBeginAllowThreads();
20541 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20542
20543 wxPyEndAllowThreads(__tstate);
20544 if (PyErr_Occurred()) SWIG_fail;
20545 }
20546 {
20547 wxDateTime * resultptr;
20548 resultptr = new wxDateTime((wxDateTime &)(result));
20549 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20550 }
20551 return resultobj;
20552 fail:
20553 return NULL;
20554 }
20555
20556
20557 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20558 PyObject *resultobj;
20559 wxDateTime *arg1 = (wxDateTime *) 0 ;
20560 wxDateTime::WeekDay arg2 ;
20561 wxDateTime *result;
20562 PyObject * obj0 = 0 ;
20563 PyObject * obj1 = 0 ;
20564 char *kwnames[] = {
20565 (char *) "self",(char *) "weekday", NULL
20566 };
20567
20568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20570 if (SWIG_arg_fail(1)) SWIG_fail;
20571 {
20572 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20573 if (SWIG_arg_fail(2)) SWIG_fail;
20574 }
20575 {
20576 PyThreadState* __tstate = wxPyBeginAllowThreads();
20577 {
20578 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20579 result = (wxDateTime *) &_result_ref;
20580 }
20581
20582 wxPyEndAllowThreads(__tstate);
20583 if (PyErr_Occurred()) SWIG_fail;
20584 }
20585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20586 return resultobj;
20587 fail:
20588 return NULL;
20589 }
20590
20591
20592 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20593 PyObject *resultobj;
20594 wxDateTime *arg1 = (wxDateTime *) 0 ;
20595 wxDateTime::WeekDay arg2 ;
20596 wxDateTime result;
20597 PyObject * obj0 = 0 ;
20598 PyObject * obj1 = 0 ;
20599 char *kwnames[] = {
20600 (char *) "self",(char *) "weekday", NULL
20601 };
20602
20603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20605 if (SWIG_arg_fail(1)) SWIG_fail;
20606 {
20607 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20608 if (SWIG_arg_fail(2)) SWIG_fail;
20609 }
20610 {
20611 PyThreadState* __tstate = wxPyBeginAllowThreads();
20612 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20613
20614 wxPyEndAllowThreads(__tstate);
20615 if (PyErr_Occurred()) SWIG_fail;
20616 }
20617 {
20618 wxDateTime * resultptr;
20619 resultptr = new wxDateTime((wxDateTime &)(result));
20620 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20621 }
20622 return resultobj;
20623 fail:
20624 return NULL;
20625 }
20626
20627
20628 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20629 PyObject *resultobj;
20630 wxDateTime *arg1 = (wxDateTime *) 0 ;
20631 wxDateTime::WeekDay arg2 ;
20632 wxDateTime *result;
20633 PyObject * obj0 = 0 ;
20634 PyObject * obj1 = 0 ;
20635 char *kwnames[] = {
20636 (char *) "self",(char *) "weekday", NULL
20637 };
20638
20639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20641 if (SWIG_arg_fail(1)) SWIG_fail;
20642 {
20643 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20644 if (SWIG_arg_fail(2)) SWIG_fail;
20645 }
20646 {
20647 PyThreadState* __tstate = wxPyBeginAllowThreads();
20648 {
20649 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20650 result = (wxDateTime *) &_result_ref;
20651 }
20652
20653 wxPyEndAllowThreads(__tstate);
20654 if (PyErr_Occurred()) SWIG_fail;
20655 }
20656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20657 return resultobj;
20658 fail:
20659 return NULL;
20660 }
20661
20662
20663 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20664 PyObject *resultobj;
20665 wxDateTime *arg1 = (wxDateTime *) 0 ;
20666 wxDateTime::WeekDay arg2 ;
20667 wxDateTime result;
20668 PyObject * obj0 = 0 ;
20669 PyObject * obj1 = 0 ;
20670 char *kwnames[] = {
20671 (char *) "self",(char *) "weekday", NULL
20672 };
20673
20674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20676 if (SWIG_arg_fail(1)) SWIG_fail;
20677 {
20678 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20679 if (SWIG_arg_fail(2)) SWIG_fail;
20680 }
20681 {
20682 PyThreadState* __tstate = wxPyBeginAllowThreads();
20683 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20684
20685 wxPyEndAllowThreads(__tstate);
20686 if (PyErr_Occurred()) SWIG_fail;
20687 }
20688 {
20689 wxDateTime * resultptr;
20690 resultptr = new wxDateTime((wxDateTime &)(result));
20691 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20692 }
20693 return resultobj;
20694 fail:
20695 return NULL;
20696 }
20697
20698
20699 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20700 PyObject *resultobj;
20701 wxDateTime *arg1 = (wxDateTime *) 0 ;
20702 wxDateTime::WeekDay arg2 ;
20703 int arg3 = (int) 1 ;
20704 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20705 int arg5 = (int) wxDateTime::Inv_Year ;
20706 bool result;
20707 PyObject * obj0 = 0 ;
20708 PyObject * obj1 = 0 ;
20709 PyObject * obj2 = 0 ;
20710 PyObject * obj3 = 0 ;
20711 PyObject * obj4 = 0 ;
20712 char *kwnames[] = {
20713 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20714 };
20715
20716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20718 if (SWIG_arg_fail(1)) SWIG_fail;
20719 {
20720 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20721 if (SWIG_arg_fail(2)) SWIG_fail;
20722 }
20723 if (obj2) {
20724 {
20725 arg3 = (int)(SWIG_As_int(obj2));
20726 if (SWIG_arg_fail(3)) SWIG_fail;
20727 }
20728 }
20729 if (obj3) {
20730 {
20731 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20732 if (SWIG_arg_fail(4)) SWIG_fail;
20733 }
20734 }
20735 if (obj4) {
20736 {
20737 arg5 = (int)(SWIG_As_int(obj4));
20738 if (SWIG_arg_fail(5)) SWIG_fail;
20739 }
20740 }
20741 {
20742 PyThreadState* __tstate = wxPyBeginAllowThreads();
20743 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20744
20745 wxPyEndAllowThreads(__tstate);
20746 if (PyErr_Occurred()) SWIG_fail;
20747 }
20748 {
20749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20750 }
20751 return resultobj;
20752 fail:
20753 return NULL;
20754 }
20755
20756
20757 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20758 PyObject *resultobj;
20759 wxDateTime *arg1 = (wxDateTime *) 0 ;
20760 wxDateTime::WeekDay arg2 ;
20761 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20762 int arg4 = (int) wxDateTime::Inv_Year ;
20763 bool result;
20764 PyObject * obj0 = 0 ;
20765 PyObject * obj1 = 0 ;
20766 PyObject * obj2 = 0 ;
20767 PyObject * obj3 = 0 ;
20768 char *kwnames[] = {
20769 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20770 };
20771
20772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20774 if (SWIG_arg_fail(1)) SWIG_fail;
20775 {
20776 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20777 if (SWIG_arg_fail(2)) SWIG_fail;
20778 }
20779 if (obj2) {
20780 {
20781 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20782 if (SWIG_arg_fail(3)) SWIG_fail;
20783 }
20784 }
20785 if (obj3) {
20786 {
20787 arg4 = (int)(SWIG_As_int(obj3));
20788 if (SWIG_arg_fail(4)) SWIG_fail;
20789 }
20790 }
20791 {
20792 PyThreadState* __tstate = wxPyBeginAllowThreads();
20793 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20794
20795 wxPyEndAllowThreads(__tstate);
20796 if (PyErr_Occurred()) SWIG_fail;
20797 }
20798 {
20799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20800 }
20801 return resultobj;
20802 fail:
20803 return NULL;
20804 }
20805
20806
20807 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20808 PyObject *resultobj;
20809 wxDateTime *arg1 = (wxDateTime *) 0 ;
20810 wxDateTime::WeekDay arg2 ;
20811 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20812 int arg4 = (int) wxDateTime::Inv_Year ;
20813 wxDateTime result;
20814 PyObject * obj0 = 0 ;
20815 PyObject * obj1 = 0 ;
20816 PyObject * obj2 = 0 ;
20817 PyObject * obj3 = 0 ;
20818 char *kwnames[] = {
20819 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20820 };
20821
20822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20824 if (SWIG_arg_fail(1)) SWIG_fail;
20825 {
20826 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20827 if (SWIG_arg_fail(2)) SWIG_fail;
20828 }
20829 if (obj2) {
20830 {
20831 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20832 if (SWIG_arg_fail(3)) SWIG_fail;
20833 }
20834 }
20835 if (obj3) {
20836 {
20837 arg4 = (int)(SWIG_As_int(obj3));
20838 if (SWIG_arg_fail(4)) SWIG_fail;
20839 }
20840 }
20841 {
20842 PyThreadState* __tstate = wxPyBeginAllowThreads();
20843 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20844
20845 wxPyEndAllowThreads(__tstate);
20846 if (PyErr_Occurred()) SWIG_fail;
20847 }
20848 {
20849 wxDateTime * resultptr;
20850 resultptr = new wxDateTime((wxDateTime &)(result));
20851 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20852 }
20853 return resultobj;
20854 fail:
20855 return NULL;
20856 }
20857
20858
20859 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20860 PyObject *resultobj;
20861 wxDateTime *arg1 = (wxDateTime *) 0 ;
20862 int arg2 ;
20863 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20864 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20865 bool result;
20866 PyObject * obj0 = 0 ;
20867 PyObject * obj1 = 0 ;
20868 PyObject * obj2 = 0 ;
20869 PyObject * obj3 = 0 ;
20870 char *kwnames[] = {
20871 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20872 };
20873
20874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20876 if (SWIG_arg_fail(1)) SWIG_fail;
20877 {
20878 arg2 = (int)(SWIG_As_int(obj1));
20879 if (SWIG_arg_fail(2)) SWIG_fail;
20880 }
20881 if (obj2) {
20882 {
20883 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20884 if (SWIG_arg_fail(3)) SWIG_fail;
20885 }
20886 }
20887 if (obj3) {
20888 {
20889 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20890 if (SWIG_arg_fail(4)) SWIG_fail;
20891 }
20892 }
20893 {
20894 PyThreadState* __tstate = wxPyBeginAllowThreads();
20895 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20896
20897 wxPyEndAllowThreads(__tstate);
20898 if (PyErr_Occurred()) SWIG_fail;
20899 }
20900 {
20901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20902 }
20903 return resultobj;
20904 fail:
20905 return NULL;
20906 }
20907
20908
20909 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20910 PyObject *resultobj;
20911 wxDateTime *arg1 = (wxDateTime *) 0 ;
20912 int arg2 ;
20913 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20914 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20915 wxDateTime result;
20916 PyObject * obj0 = 0 ;
20917 PyObject * obj1 = 0 ;
20918 PyObject * obj2 = 0 ;
20919 PyObject * obj3 = 0 ;
20920 char *kwnames[] = {
20921 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20922 };
20923
20924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20926 if (SWIG_arg_fail(1)) SWIG_fail;
20927 {
20928 arg2 = (int)(SWIG_As_int(obj1));
20929 if (SWIG_arg_fail(2)) SWIG_fail;
20930 }
20931 if (obj2) {
20932 {
20933 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20934 if (SWIG_arg_fail(3)) SWIG_fail;
20935 }
20936 }
20937 if (obj3) {
20938 {
20939 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20940 if (SWIG_arg_fail(4)) SWIG_fail;
20941 }
20942 }
20943 {
20944 PyThreadState* __tstate = wxPyBeginAllowThreads();
20945 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20946
20947 wxPyEndAllowThreads(__tstate);
20948 if (PyErr_Occurred()) SWIG_fail;
20949 }
20950 {
20951 wxDateTime * resultptr;
20952 resultptr = new wxDateTime((wxDateTime &)(result));
20953 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20954 }
20955 return resultobj;
20956 fail:
20957 return NULL;
20958 }
20959
20960
20961 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20962 PyObject *resultobj;
20963 int arg1 ;
20964 int arg2 ;
20965 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20966 wxDateTime result;
20967 PyObject * obj0 = 0 ;
20968 PyObject * obj1 = 0 ;
20969 PyObject * obj2 = 0 ;
20970 char *kwnames[] = {
20971 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20972 };
20973
20974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20975 {
20976 arg1 = (int)(SWIG_As_int(obj0));
20977 if (SWIG_arg_fail(1)) SWIG_fail;
20978 }
20979 {
20980 arg2 = (int)(SWIG_As_int(obj1));
20981 if (SWIG_arg_fail(2)) SWIG_fail;
20982 }
20983 if (obj2) {
20984 {
20985 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20986 if (SWIG_arg_fail(3)) SWIG_fail;
20987 }
20988 }
20989 {
20990 PyThreadState* __tstate = wxPyBeginAllowThreads();
20991 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )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_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21008 PyObject *resultobj;
21009 wxDateTime *arg1 = (wxDateTime *) 0 ;
21010 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21011 int arg3 = (int) wxDateTime::Inv_Year ;
21012 wxDateTime *result;
21013 PyObject * obj0 = 0 ;
21014 PyObject * obj1 = 0 ;
21015 PyObject * obj2 = 0 ;
21016 char *kwnames[] = {
21017 (char *) "self",(char *) "month",(char *) "year", NULL
21018 };
21019
21020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21022 if (SWIG_arg_fail(1)) SWIG_fail;
21023 if (obj1) {
21024 {
21025 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21026 if (SWIG_arg_fail(2)) SWIG_fail;
21027 }
21028 }
21029 if (obj2) {
21030 {
21031 arg3 = (int)(SWIG_As_int(obj2));
21032 if (SWIG_arg_fail(3)) SWIG_fail;
21033 }
21034 }
21035 {
21036 PyThreadState* __tstate = wxPyBeginAllowThreads();
21037 {
21038 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
21039 result = (wxDateTime *) &_result_ref;
21040 }
21041
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21046 return resultobj;
21047 fail:
21048 return NULL;
21049 }
21050
21051
21052 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21053 PyObject *resultobj;
21054 wxDateTime *arg1 = (wxDateTime *) 0 ;
21055 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21056 int arg3 = (int) wxDateTime::Inv_Year ;
21057 wxDateTime result;
21058 PyObject * obj0 = 0 ;
21059 PyObject * obj1 = 0 ;
21060 PyObject * obj2 = 0 ;
21061 char *kwnames[] = {
21062 (char *) "self",(char *) "month",(char *) "year", NULL
21063 };
21064
21065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21067 if (SWIG_arg_fail(1)) SWIG_fail;
21068 if (obj1) {
21069 {
21070 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21071 if (SWIG_arg_fail(2)) SWIG_fail;
21072 }
21073 }
21074 if (obj2) {
21075 {
21076 arg3 = (int)(SWIG_As_int(obj2));
21077 if (SWIG_arg_fail(3)) SWIG_fail;
21078 }
21079 }
21080 {
21081 PyThreadState* __tstate = wxPyBeginAllowThreads();
21082 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21083
21084 wxPyEndAllowThreads(__tstate);
21085 if (PyErr_Occurred()) SWIG_fail;
21086 }
21087 {
21088 wxDateTime * resultptr;
21089 resultptr = new wxDateTime((wxDateTime &)(result));
21090 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21091 }
21092 return resultobj;
21093 fail:
21094 return NULL;
21095 }
21096
21097
21098 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21099 PyObject *resultobj;
21100 wxDateTime *arg1 = (wxDateTime *) 0 ;
21101 int arg2 ;
21102 wxDateTime *result;
21103 PyObject * obj0 = 0 ;
21104 PyObject * obj1 = 0 ;
21105 char *kwnames[] = {
21106 (char *) "self",(char *) "yday", NULL
21107 };
21108
21109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21111 if (SWIG_arg_fail(1)) SWIG_fail;
21112 {
21113 arg2 = (int)(SWIG_As_int(obj1));
21114 if (SWIG_arg_fail(2)) SWIG_fail;
21115 }
21116 {
21117 PyThreadState* __tstate = wxPyBeginAllowThreads();
21118 {
21119 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21120 result = (wxDateTime *) &_result_ref;
21121 }
21122
21123 wxPyEndAllowThreads(__tstate);
21124 if (PyErr_Occurred()) SWIG_fail;
21125 }
21126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21127 return resultobj;
21128 fail:
21129 return NULL;
21130 }
21131
21132
21133 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21134 PyObject *resultobj;
21135 wxDateTime *arg1 = (wxDateTime *) 0 ;
21136 int arg2 ;
21137 wxDateTime result;
21138 PyObject * obj0 = 0 ;
21139 PyObject * obj1 = 0 ;
21140 char *kwnames[] = {
21141 (char *) "self",(char *) "yday", NULL
21142 };
21143
21144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21146 if (SWIG_arg_fail(1)) SWIG_fail;
21147 {
21148 arg2 = (int)(SWIG_As_int(obj1));
21149 if (SWIG_arg_fail(2)) SWIG_fail;
21150 }
21151 {
21152 PyThreadState* __tstate = wxPyBeginAllowThreads();
21153 result = (arg1)->GetYearDay(arg2);
21154
21155 wxPyEndAllowThreads(__tstate);
21156 if (PyErr_Occurred()) SWIG_fail;
21157 }
21158 {
21159 wxDateTime * resultptr;
21160 resultptr = new wxDateTime((wxDateTime &)(result));
21161 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21162 }
21163 return resultobj;
21164 fail:
21165 return NULL;
21166 }
21167
21168
21169 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21170 PyObject *resultobj;
21171 wxDateTime *arg1 = (wxDateTime *) 0 ;
21172 double result;
21173 PyObject * obj0 = 0 ;
21174 char *kwnames[] = {
21175 (char *) "self", NULL
21176 };
21177
21178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21180 if (SWIG_arg_fail(1)) SWIG_fail;
21181 {
21182 PyThreadState* __tstate = wxPyBeginAllowThreads();
21183 result = (double)(arg1)->GetJulianDayNumber();
21184
21185 wxPyEndAllowThreads(__tstate);
21186 if (PyErr_Occurred()) SWIG_fail;
21187 }
21188 {
21189 resultobj = SWIG_From_double((double)(result));
21190 }
21191 return resultobj;
21192 fail:
21193 return NULL;
21194 }
21195
21196
21197 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21198 PyObject *resultobj;
21199 wxDateTime *arg1 = (wxDateTime *) 0 ;
21200 double result;
21201 PyObject * obj0 = 0 ;
21202 char *kwnames[] = {
21203 (char *) "self", NULL
21204 };
21205
21206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21208 if (SWIG_arg_fail(1)) SWIG_fail;
21209 {
21210 PyThreadState* __tstate = wxPyBeginAllowThreads();
21211 result = (double)(arg1)->GetJDN();
21212
21213 wxPyEndAllowThreads(__tstate);
21214 if (PyErr_Occurred()) SWIG_fail;
21215 }
21216 {
21217 resultobj = SWIG_From_double((double)(result));
21218 }
21219 return resultobj;
21220 fail:
21221 return NULL;
21222 }
21223
21224
21225 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21226 PyObject *resultobj;
21227 wxDateTime *arg1 = (wxDateTime *) 0 ;
21228 double result;
21229 PyObject * obj0 = 0 ;
21230 char *kwnames[] = {
21231 (char *) "self", NULL
21232 };
21233
21234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21236 if (SWIG_arg_fail(1)) SWIG_fail;
21237 {
21238 PyThreadState* __tstate = wxPyBeginAllowThreads();
21239 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21240
21241 wxPyEndAllowThreads(__tstate);
21242 if (PyErr_Occurred()) SWIG_fail;
21243 }
21244 {
21245 resultobj = SWIG_From_double((double)(result));
21246 }
21247 return resultobj;
21248 fail:
21249 return NULL;
21250 }
21251
21252
21253 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21254 PyObject *resultobj;
21255 wxDateTime *arg1 = (wxDateTime *) 0 ;
21256 double result;
21257 PyObject * obj0 = 0 ;
21258 char *kwnames[] = {
21259 (char *) "self", NULL
21260 };
21261
21262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21264 if (SWIG_arg_fail(1)) SWIG_fail;
21265 {
21266 PyThreadState* __tstate = wxPyBeginAllowThreads();
21267 result = (double)(arg1)->GetMJD();
21268
21269 wxPyEndAllowThreads(__tstate);
21270 if (PyErr_Occurred()) SWIG_fail;
21271 }
21272 {
21273 resultobj = SWIG_From_double((double)(result));
21274 }
21275 return resultobj;
21276 fail:
21277 return NULL;
21278 }
21279
21280
21281 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21282 PyObject *resultobj;
21283 wxDateTime *arg1 = (wxDateTime *) 0 ;
21284 double result;
21285 PyObject * obj0 = 0 ;
21286 char *kwnames[] = {
21287 (char *) "self", NULL
21288 };
21289
21290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21292 if (SWIG_arg_fail(1)) SWIG_fail;
21293 {
21294 PyThreadState* __tstate = wxPyBeginAllowThreads();
21295 result = (double)(arg1)->GetRataDie();
21296
21297 wxPyEndAllowThreads(__tstate);
21298 if (PyErr_Occurred()) SWIG_fail;
21299 }
21300 {
21301 resultobj = SWIG_From_double((double)(result));
21302 }
21303 return resultobj;
21304 fail:
21305 return NULL;
21306 }
21307
21308
21309 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21310 PyObject *resultobj;
21311 wxDateTime *arg1 = (wxDateTime *) 0 ;
21312 wxDateTime::TimeZone *arg2 = 0 ;
21313 bool arg3 = (bool) false ;
21314 wxDateTime result;
21315 bool temp2 = false ;
21316 PyObject * obj0 = 0 ;
21317 PyObject * obj1 = 0 ;
21318 PyObject * obj2 = 0 ;
21319 char *kwnames[] = {
21320 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21321 };
21322
21323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21325 if (SWIG_arg_fail(1)) SWIG_fail;
21326 {
21327 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21328 temp2 = true;
21329 }
21330 if (obj2) {
21331 {
21332 arg3 = (bool)(SWIG_As_bool(obj2));
21333 if (SWIG_arg_fail(3)) SWIG_fail;
21334 }
21335 }
21336 {
21337 PyThreadState* __tstate = wxPyBeginAllowThreads();
21338 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21339
21340 wxPyEndAllowThreads(__tstate);
21341 if (PyErr_Occurred()) SWIG_fail;
21342 }
21343 {
21344 wxDateTime * resultptr;
21345 resultptr = new wxDateTime((wxDateTime &)(result));
21346 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21347 }
21348 {
21349 if (temp2) delete arg2;
21350 }
21351 return resultobj;
21352 fail:
21353 {
21354 if (temp2) delete arg2;
21355 }
21356 return NULL;
21357 }
21358
21359
21360 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21361 PyObject *resultobj;
21362 wxDateTime *arg1 = (wxDateTime *) 0 ;
21363 wxDateTime::TimeZone *arg2 = 0 ;
21364 bool arg3 = (bool) false ;
21365 wxDateTime *result;
21366 bool temp2 = false ;
21367 PyObject * obj0 = 0 ;
21368 PyObject * obj1 = 0 ;
21369 PyObject * obj2 = 0 ;
21370 char *kwnames[] = {
21371 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21372 };
21373
21374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21376 if (SWIG_arg_fail(1)) SWIG_fail;
21377 {
21378 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21379 temp2 = true;
21380 }
21381 if (obj2) {
21382 {
21383 arg3 = (bool)(SWIG_As_bool(obj2));
21384 if (SWIG_arg_fail(3)) SWIG_fail;
21385 }
21386 }
21387 {
21388 PyThreadState* __tstate = wxPyBeginAllowThreads();
21389 {
21390 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21391 result = (wxDateTime *) &_result_ref;
21392 }
21393
21394 wxPyEndAllowThreads(__tstate);
21395 if (PyErr_Occurred()) SWIG_fail;
21396 }
21397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21398 {
21399 if (temp2) delete arg2;
21400 }
21401 return resultobj;
21402 fail:
21403 {
21404 if (temp2) delete arg2;
21405 }
21406 return NULL;
21407 }
21408
21409
21410 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21411 PyObject *resultobj;
21412 wxDateTime *arg1 = (wxDateTime *) 0 ;
21413 bool arg2 = (bool) false ;
21414 wxDateTime result;
21415 PyObject * obj0 = 0 ;
21416 PyObject * obj1 = 0 ;
21417 char *kwnames[] = {
21418 (char *) "self",(char *) "noDST", NULL
21419 };
21420
21421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21423 if (SWIG_arg_fail(1)) SWIG_fail;
21424 if (obj1) {
21425 {
21426 arg2 = (bool)(SWIG_As_bool(obj1));
21427 if (SWIG_arg_fail(2)) SWIG_fail;
21428 }
21429 }
21430 {
21431 PyThreadState* __tstate = wxPyBeginAllowThreads();
21432 result = (arg1)->ToGMT(arg2);
21433
21434 wxPyEndAllowThreads(__tstate);
21435 if (PyErr_Occurred()) SWIG_fail;
21436 }
21437 {
21438 wxDateTime * resultptr;
21439 resultptr = new wxDateTime((wxDateTime &)(result));
21440 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21441 }
21442 return resultobj;
21443 fail:
21444 return NULL;
21445 }
21446
21447
21448 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21449 PyObject *resultobj;
21450 wxDateTime *arg1 = (wxDateTime *) 0 ;
21451 bool arg2 = (bool) false ;
21452 wxDateTime *result;
21453 PyObject * obj0 = 0 ;
21454 PyObject * obj1 = 0 ;
21455 char *kwnames[] = {
21456 (char *) "self",(char *) "noDST", NULL
21457 };
21458
21459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21461 if (SWIG_arg_fail(1)) SWIG_fail;
21462 if (obj1) {
21463 {
21464 arg2 = (bool)(SWIG_As_bool(obj1));
21465 if (SWIG_arg_fail(2)) SWIG_fail;
21466 }
21467 }
21468 {
21469 PyThreadState* __tstate = wxPyBeginAllowThreads();
21470 {
21471 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21472 result = (wxDateTime *) &_result_ref;
21473 }
21474
21475 wxPyEndAllowThreads(__tstate);
21476 if (PyErr_Occurred()) SWIG_fail;
21477 }
21478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21479 return resultobj;
21480 fail:
21481 return NULL;
21482 }
21483
21484
21485 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21486 PyObject *resultobj;
21487 wxDateTime *arg1 = (wxDateTime *) 0 ;
21488 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21489 int result;
21490 PyObject * obj0 = 0 ;
21491 PyObject * obj1 = 0 ;
21492 char *kwnames[] = {
21493 (char *) "self",(char *) "country", NULL
21494 };
21495
21496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21498 if (SWIG_arg_fail(1)) SWIG_fail;
21499 if (obj1) {
21500 {
21501 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21502 if (SWIG_arg_fail(2)) SWIG_fail;
21503 }
21504 }
21505 {
21506 PyThreadState* __tstate = wxPyBeginAllowThreads();
21507 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21508
21509 wxPyEndAllowThreads(__tstate);
21510 if (PyErr_Occurred()) SWIG_fail;
21511 }
21512 {
21513 resultobj = SWIG_From_int((int)(result));
21514 }
21515 return resultobj;
21516 fail:
21517 return NULL;
21518 }
21519
21520
21521 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21522 PyObject *resultobj;
21523 wxDateTime *arg1 = (wxDateTime *) 0 ;
21524 bool result;
21525 PyObject * obj0 = 0 ;
21526 char *kwnames[] = {
21527 (char *) "self", NULL
21528 };
21529
21530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21532 if (SWIG_arg_fail(1)) SWIG_fail;
21533 {
21534 PyThreadState* __tstate = wxPyBeginAllowThreads();
21535 result = (bool)((wxDateTime const *)arg1)->IsValid();
21536
21537 wxPyEndAllowThreads(__tstate);
21538 if (PyErr_Occurred()) SWIG_fail;
21539 }
21540 {
21541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21542 }
21543 return resultobj;
21544 fail:
21545 return NULL;
21546 }
21547
21548
21549 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21550 PyObject *resultobj;
21551 wxDateTime *arg1 = (wxDateTime *) 0 ;
21552 time_t result;
21553 PyObject * obj0 = 0 ;
21554 char *kwnames[] = {
21555 (char *) "self", NULL
21556 };
21557
21558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21560 if (SWIG_arg_fail(1)) SWIG_fail;
21561 {
21562 PyThreadState* __tstate = wxPyBeginAllowThreads();
21563 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21564
21565 wxPyEndAllowThreads(__tstate);
21566 if (PyErr_Occurred()) SWIG_fail;
21567 }
21568 {
21569 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21570 }
21571 return resultobj;
21572 fail:
21573 return NULL;
21574 }
21575
21576
21577 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21578 PyObject *resultobj;
21579 wxDateTime *arg1 = (wxDateTime *) 0 ;
21580 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21581 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21582 int result;
21583 bool temp2 = false ;
21584 PyObject * obj0 = 0 ;
21585 PyObject * obj1 = 0 ;
21586 char *kwnames[] = {
21587 (char *) "self",(char *) "tz", NULL
21588 };
21589
21590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21592 if (SWIG_arg_fail(1)) SWIG_fail;
21593 if (obj1) {
21594 {
21595 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21596 temp2 = true;
21597 }
21598 }
21599 {
21600 PyThreadState* __tstate = wxPyBeginAllowThreads();
21601 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21602
21603 wxPyEndAllowThreads(__tstate);
21604 if (PyErr_Occurred()) SWIG_fail;
21605 }
21606 {
21607 resultobj = SWIG_From_int((int)(result));
21608 }
21609 {
21610 if (temp2) delete arg2;
21611 }
21612 return resultobj;
21613 fail:
21614 {
21615 if (temp2) delete arg2;
21616 }
21617 return NULL;
21618 }
21619
21620
21621 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21622 PyObject *resultobj;
21623 wxDateTime *arg1 = (wxDateTime *) 0 ;
21624 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21625 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21626 wxDateTime::Month result;
21627 bool temp2 = false ;
21628 PyObject * obj0 = 0 ;
21629 PyObject * obj1 = 0 ;
21630 char *kwnames[] = {
21631 (char *) "self",(char *) "tz", NULL
21632 };
21633
21634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21636 if (SWIG_arg_fail(1)) SWIG_fail;
21637 if (obj1) {
21638 {
21639 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21640 temp2 = true;
21641 }
21642 }
21643 {
21644 PyThreadState* __tstate = wxPyBeginAllowThreads();
21645 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21646
21647 wxPyEndAllowThreads(__tstate);
21648 if (PyErr_Occurred()) SWIG_fail;
21649 }
21650 resultobj = SWIG_From_int((result));
21651 {
21652 if (temp2) delete arg2;
21653 }
21654 return resultobj;
21655 fail:
21656 {
21657 if (temp2) delete arg2;
21658 }
21659 return NULL;
21660 }
21661
21662
21663 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21664 PyObject *resultobj;
21665 wxDateTime *arg1 = (wxDateTime *) 0 ;
21666 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21667 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21668 int result;
21669 bool temp2 = false ;
21670 PyObject * obj0 = 0 ;
21671 PyObject * obj1 = 0 ;
21672 char *kwnames[] = {
21673 (char *) "self",(char *) "tz", NULL
21674 };
21675
21676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21678 if (SWIG_arg_fail(1)) SWIG_fail;
21679 if (obj1) {
21680 {
21681 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21682 temp2 = true;
21683 }
21684 }
21685 {
21686 PyThreadState* __tstate = wxPyBeginAllowThreads();
21687 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21688
21689 wxPyEndAllowThreads(__tstate);
21690 if (PyErr_Occurred()) SWIG_fail;
21691 }
21692 {
21693 resultobj = SWIG_From_int((int)(result));
21694 }
21695 {
21696 if (temp2) delete arg2;
21697 }
21698 return resultobj;
21699 fail:
21700 {
21701 if (temp2) delete arg2;
21702 }
21703 return NULL;
21704 }
21705
21706
21707 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21708 PyObject *resultobj;
21709 wxDateTime *arg1 = (wxDateTime *) 0 ;
21710 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21711 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21712 wxDateTime::WeekDay result;
21713 bool temp2 = false ;
21714 PyObject * obj0 = 0 ;
21715 PyObject * obj1 = 0 ;
21716 char *kwnames[] = {
21717 (char *) "self",(char *) "tz", NULL
21718 };
21719
21720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21722 if (SWIG_arg_fail(1)) SWIG_fail;
21723 if (obj1) {
21724 {
21725 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21726 temp2 = true;
21727 }
21728 }
21729 {
21730 PyThreadState* __tstate = wxPyBeginAllowThreads();
21731 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21732
21733 wxPyEndAllowThreads(__tstate);
21734 if (PyErr_Occurred()) SWIG_fail;
21735 }
21736 resultobj = SWIG_From_int((result));
21737 {
21738 if (temp2) delete arg2;
21739 }
21740 return resultobj;
21741 fail:
21742 {
21743 if (temp2) delete arg2;
21744 }
21745 return NULL;
21746 }
21747
21748
21749 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21750 PyObject *resultobj;
21751 wxDateTime *arg1 = (wxDateTime *) 0 ;
21752 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21753 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21754 int result;
21755 bool temp2 = false ;
21756 PyObject * obj0 = 0 ;
21757 PyObject * obj1 = 0 ;
21758 char *kwnames[] = {
21759 (char *) "self",(char *) "tz", NULL
21760 };
21761
21762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21764 if (SWIG_arg_fail(1)) SWIG_fail;
21765 if (obj1) {
21766 {
21767 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21768 temp2 = true;
21769 }
21770 }
21771 {
21772 PyThreadState* __tstate = wxPyBeginAllowThreads();
21773 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21774
21775 wxPyEndAllowThreads(__tstate);
21776 if (PyErr_Occurred()) SWIG_fail;
21777 }
21778 {
21779 resultobj = SWIG_From_int((int)(result));
21780 }
21781 {
21782 if (temp2) delete arg2;
21783 }
21784 return resultobj;
21785 fail:
21786 {
21787 if (temp2) delete arg2;
21788 }
21789 return NULL;
21790 }
21791
21792
21793 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21794 PyObject *resultobj;
21795 wxDateTime *arg1 = (wxDateTime *) 0 ;
21796 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21797 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21798 int result;
21799 bool temp2 = false ;
21800 PyObject * obj0 = 0 ;
21801 PyObject * obj1 = 0 ;
21802 char *kwnames[] = {
21803 (char *) "self",(char *) "tz", NULL
21804 };
21805
21806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21808 if (SWIG_arg_fail(1)) SWIG_fail;
21809 if (obj1) {
21810 {
21811 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21812 temp2 = true;
21813 }
21814 }
21815 {
21816 PyThreadState* __tstate = wxPyBeginAllowThreads();
21817 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21818
21819 wxPyEndAllowThreads(__tstate);
21820 if (PyErr_Occurred()) SWIG_fail;
21821 }
21822 {
21823 resultobj = SWIG_From_int((int)(result));
21824 }
21825 {
21826 if (temp2) delete arg2;
21827 }
21828 return resultobj;
21829 fail:
21830 {
21831 if (temp2) delete arg2;
21832 }
21833 return NULL;
21834 }
21835
21836
21837 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21838 PyObject *resultobj;
21839 wxDateTime *arg1 = (wxDateTime *) 0 ;
21840 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21841 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21842 int result;
21843 bool temp2 = false ;
21844 PyObject * obj0 = 0 ;
21845 PyObject * obj1 = 0 ;
21846 char *kwnames[] = {
21847 (char *) "self",(char *) "tz", NULL
21848 };
21849
21850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21852 if (SWIG_arg_fail(1)) SWIG_fail;
21853 if (obj1) {
21854 {
21855 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21856 temp2 = true;
21857 }
21858 }
21859 {
21860 PyThreadState* __tstate = wxPyBeginAllowThreads();
21861 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21862
21863 wxPyEndAllowThreads(__tstate);
21864 if (PyErr_Occurred()) SWIG_fail;
21865 }
21866 {
21867 resultobj = SWIG_From_int((int)(result));
21868 }
21869 {
21870 if (temp2) delete arg2;
21871 }
21872 return resultobj;
21873 fail:
21874 {
21875 if (temp2) delete arg2;
21876 }
21877 return NULL;
21878 }
21879
21880
21881 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21882 PyObject *resultobj;
21883 wxDateTime *arg1 = (wxDateTime *) 0 ;
21884 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21885 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21886 int result;
21887 bool temp2 = false ;
21888 PyObject * obj0 = 0 ;
21889 PyObject * obj1 = 0 ;
21890 char *kwnames[] = {
21891 (char *) "self",(char *) "tz", NULL
21892 };
21893
21894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21896 if (SWIG_arg_fail(1)) SWIG_fail;
21897 if (obj1) {
21898 {
21899 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21900 temp2 = true;
21901 }
21902 }
21903 {
21904 PyThreadState* __tstate = wxPyBeginAllowThreads();
21905 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21906
21907 wxPyEndAllowThreads(__tstate);
21908 if (PyErr_Occurred()) SWIG_fail;
21909 }
21910 {
21911 resultobj = SWIG_From_int((int)(result));
21912 }
21913 {
21914 if (temp2) delete arg2;
21915 }
21916 return resultobj;
21917 fail:
21918 {
21919 if (temp2) delete arg2;
21920 }
21921 return NULL;
21922 }
21923
21924
21925 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21926 PyObject *resultobj;
21927 wxDateTime *arg1 = (wxDateTime *) 0 ;
21928 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21929 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21930 int result;
21931 bool temp2 = false ;
21932 PyObject * obj0 = 0 ;
21933 PyObject * obj1 = 0 ;
21934 char *kwnames[] = {
21935 (char *) "self",(char *) "tz", NULL
21936 };
21937
21938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21940 if (SWIG_arg_fail(1)) SWIG_fail;
21941 if (obj1) {
21942 {
21943 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21944 temp2 = true;
21945 }
21946 }
21947 {
21948 PyThreadState* __tstate = wxPyBeginAllowThreads();
21949 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21950
21951 wxPyEndAllowThreads(__tstate);
21952 if (PyErr_Occurred()) SWIG_fail;
21953 }
21954 {
21955 resultobj = SWIG_From_int((int)(result));
21956 }
21957 {
21958 if (temp2) delete arg2;
21959 }
21960 return resultobj;
21961 fail:
21962 {
21963 if (temp2) delete arg2;
21964 }
21965 return NULL;
21966 }
21967
21968
21969 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21970 PyObject *resultobj;
21971 wxDateTime *arg1 = (wxDateTime *) 0 ;
21972 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21973 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21974 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21975 int result;
21976 bool temp3 = false ;
21977 PyObject * obj0 = 0 ;
21978 PyObject * obj1 = 0 ;
21979 PyObject * obj2 = 0 ;
21980 char *kwnames[] = {
21981 (char *) "self",(char *) "flags",(char *) "tz", NULL
21982 };
21983
21984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21986 if (SWIG_arg_fail(1)) SWIG_fail;
21987 if (obj1) {
21988 {
21989 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21990 if (SWIG_arg_fail(2)) SWIG_fail;
21991 }
21992 }
21993 if (obj2) {
21994 {
21995 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21996 temp3 = true;
21997 }
21998 }
21999 {
22000 PyThreadState* __tstate = wxPyBeginAllowThreads();
22001 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22002
22003 wxPyEndAllowThreads(__tstate);
22004 if (PyErr_Occurred()) SWIG_fail;
22005 }
22006 {
22007 resultobj = SWIG_From_int((int)(result));
22008 }
22009 {
22010 if (temp3) delete arg3;
22011 }
22012 return resultobj;
22013 fail:
22014 {
22015 if (temp3) delete arg3;
22016 }
22017 return NULL;
22018 }
22019
22020
22021 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22022 PyObject *resultobj;
22023 wxDateTime *arg1 = (wxDateTime *) 0 ;
22024 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22025 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22026 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22027 int result;
22028 bool temp3 = false ;
22029 PyObject * obj0 = 0 ;
22030 PyObject * obj1 = 0 ;
22031 PyObject * obj2 = 0 ;
22032 char *kwnames[] = {
22033 (char *) "self",(char *) "flags",(char *) "tz", NULL
22034 };
22035
22036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
22037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22038 if (SWIG_arg_fail(1)) SWIG_fail;
22039 if (obj1) {
22040 {
22041 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22042 if (SWIG_arg_fail(2)) SWIG_fail;
22043 }
22044 }
22045 if (obj2) {
22046 {
22047 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22048 temp3 = true;
22049 }
22050 }
22051 {
22052 PyThreadState* __tstate = wxPyBeginAllowThreads();
22053 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22054
22055 wxPyEndAllowThreads(__tstate);
22056 if (PyErr_Occurred()) SWIG_fail;
22057 }
22058 {
22059 resultobj = SWIG_From_int((int)(result));
22060 }
22061 {
22062 if (temp3) delete arg3;
22063 }
22064 return resultobj;
22065 fail:
22066 {
22067 if (temp3) delete arg3;
22068 }
22069 return NULL;
22070 }
22071
22072
22073 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22074 PyObject *resultobj;
22075 wxDateTime *arg1 = (wxDateTime *) 0 ;
22076 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22077 bool result;
22078 PyObject * obj0 = 0 ;
22079 PyObject * obj1 = 0 ;
22080 char *kwnames[] = {
22081 (char *) "self",(char *) "country", NULL
22082 };
22083
22084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22086 if (SWIG_arg_fail(1)) SWIG_fail;
22087 if (obj1) {
22088 {
22089 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22090 if (SWIG_arg_fail(2)) SWIG_fail;
22091 }
22092 }
22093 {
22094 PyThreadState* __tstate = wxPyBeginAllowThreads();
22095 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22096
22097 wxPyEndAllowThreads(__tstate);
22098 if (PyErr_Occurred()) SWIG_fail;
22099 }
22100 {
22101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22102 }
22103 return resultobj;
22104 fail:
22105 return NULL;
22106 }
22107
22108
22109 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22110 PyObject *resultobj;
22111 wxDateTime *arg1 = (wxDateTime *) 0 ;
22112 wxDateTime *arg2 = 0 ;
22113 bool result;
22114 PyObject * obj0 = 0 ;
22115 PyObject * obj1 = 0 ;
22116 char *kwnames[] = {
22117 (char *) "self",(char *) "datetime", NULL
22118 };
22119
22120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22122 if (SWIG_arg_fail(1)) SWIG_fail;
22123 {
22124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22125 if (SWIG_arg_fail(2)) SWIG_fail;
22126 if (arg2 == NULL) {
22127 SWIG_null_ref("wxDateTime");
22128 }
22129 if (SWIG_arg_fail(2)) SWIG_fail;
22130 }
22131 {
22132 PyThreadState* __tstate = wxPyBeginAllowThreads();
22133 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22134
22135 wxPyEndAllowThreads(__tstate);
22136 if (PyErr_Occurred()) SWIG_fail;
22137 }
22138 {
22139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22140 }
22141 return resultobj;
22142 fail:
22143 return NULL;
22144 }
22145
22146
22147 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22148 PyObject *resultobj;
22149 wxDateTime *arg1 = (wxDateTime *) 0 ;
22150 wxDateTime *arg2 = 0 ;
22151 bool result;
22152 PyObject * obj0 = 0 ;
22153 PyObject * obj1 = 0 ;
22154 char *kwnames[] = {
22155 (char *) "self",(char *) "datetime", NULL
22156 };
22157
22158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22160 if (SWIG_arg_fail(1)) SWIG_fail;
22161 {
22162 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22163 if (SWIG_arg_fail(2)) SWIG_fail;
22164 if (arg2 == NULL) {
22165 SWIG_null_ref("wxDateTime");
22166 }
22167 if (SWIG_arg_fail(2)) SWIG_fail;
22168 }
22169 {
22170 PyThreadState* __tstate = wxPyBeginAllowThreads();
22171 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22172
22173 wxPyEndAllowThreads(__tstate);
22174 if (PyErr_Occurred()) SWIG_fail;
22175 }
22176 {
22177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22178 }
22179 return resultobj;
22180 fail:
22181 return NULL;
22182 }
22183
22184
22185 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22186 PyObject *resultobj;
22187 wxDateTime *arg1 = (wxDateTime *) 0 ;
22188 wxDateTime *arg2 = 0 ;
22189 bool result;
22190 PyObject * obj0 = 0 ;
22191 PyObject * obj1 = 0 ;
22192 char *kwnames[] = {
22193 (char *) "self",(char *) "datetime", NULL
22194 };
22195
22196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22198 if (SWIG_arg_fail(1)) SWIG_fail;
22199 {
22200 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22201 if (SWIG_arg_fail(2)) SWIG_fail;
22202 if (arg2 == NULL) {
22203 SWIG_null_ref("wxDateTime");
22204 }
22205 if (SWIG_arg_fail(2)) SWIG_fail;
22206 }
22207 {
22208 PyThreadState* __tstate = wxPyBeginAllowThreads();
22209 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22210
22211 wxPyEndAllowThreads(__tstate);
22212 if (PyErr_Occurred()) SWIG_fail;
22213 }
22214 {
22215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22216 }
22217 return resultobj;
22218 fail:
22219 return NULL;
22220 }
22221
22222
22223 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22224 PyObject *resultobj;
22225 wxDateTime *arg1 = (wxDateTime *) 0 ;
22226 wxDateTime *arg2 = 0 ;
22227 wxDateTime *arg3 = 0 ;
22228 bool result;
22229 PyObject * obj0 = 0 ;
22230 PyObject * obj1 = 0 ;
22231 PyObject * obj2 = 0 ;
22232 char *kwnames[] = {
22233 (char *) "self",(char *) "t1",(char *) "t2", NULL
22234 };
22235
22236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22238 if (SWIG_arg_fail(1)) SWIG_fail;
22239 {
22240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22241 if (SWIG_arg_fail(2)) SWIG_fail;
22242 if (arg2 == NULL) {
22243 SWIG_null_ref("wxDateTime");
22244 }
22245 if (SWIG_arg_fail(2)) SWIG_fail;
22246 }
22247 {
22248 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22249 if (SWIG_arg_fail(3)) SWIG_fail;
22250 if (arg3 == NULL) {
22251 SWIG_null_ref("wxDateTime");
22252 }
22253 if (SWIG_arg_fail(3)) SWIG_fail;
22254 }
22255 {
22256 PyThreadState* __tstate = wxPyBeginAllowThreads();
22257 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22258
22259 wxPyEndAllowThreads(__tstate);
22260 if (PyErr_Occurred()) SWIG_fail;
22261 }
22262 {
22263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22264 }
22265 return resultobj;
22266 fail:
22267 return NULL;
22268 }
22269
22270
22271 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22272 PyObject *resultobj;
22273 wxDateTime *arg1 = (wxDateTime *) 0 ;
22274 wxDateTime *arg2 = 0 ;
22275 wxDateTime *arg3 = 0 ;
22276 bool result;
22277 PyObject * obj0 = 0 ;
22278 PyObject * obj1 = 0 ;
22279 PyObject * obj2 = 0 ;
22280 char *kwnames[] = {
22281 (char *) "self",(char *) "t1",(char *) "t2", NULL
22282 };
22283
22284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22286 if (SWIG_arg_fail(1)) SWIG_fail;
22287 {
22288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22289 if (SWIG_arg_fail(2)) SWIG_fail;
22290 if (arg2 == NULL) {
22291 SWIG_null_ref("wxDateTime");
22292 }
22293 if (SWIG_arg_fail(2)) SWIG_fail;
22294 }
22295 {
22296 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22297 if (SWIG_arg_fail(3)) SWIG_fail;
22298 if (arg3 == NULL) {
22299 SWIG_null_ref("wxDateTime");
22300 }
22301 if (SWIG_arg_fail(3)) SWIG_fail;
22302 }
22303 {
22304 PyThreadState* __tstate = wxPyBeginAllowThreads();
22305 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22306
22307 wxPyEndAllowThreads(__tstate);
22308 if (PyErr_Occurred()) SWIG_fail;
22309 }
22310 {
22311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22312 }
22313 return resultobj;
22314 fail:
22315 return NULL;
22316 }
22317
22318
22319 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22320 PyObject *resultobj;
22321 wxDateTime *arg1 = (wxDateTime *) 0 ;
22322 wxDateTime *arg2 = 0 ;
22323 bool result;
22324 PyObject * obj0 = 0 ;
22325 PyObject * obj1 = 0 ;
22326 char *kwnames[] = {
22327 (char *) "self",(char *) "dt", NULL
22328 };
22329
22330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22332 if (SWIG_arg_fail(1)) SWIG_fail;
22333 {
22334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22335 if (SWIG_arg_fail(2)) SWIG_fail;
22336 if (arg2 == NULL) {
22337 SWIG_null_ref("wxDateTime");
22338 }
22339 if (SWIG_arg_fail(2)) SWIG_fail;
22340 }
22341 {
22342 PyThreadState* __tstate = wxPyBeginAllowThreads();
22343 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22344
22345 wxPyEndAllowThreads(__tstate);
22346 if (PyErr_Occurred()) SWIG_fail;
22347 }
22348 {
22349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22350 }
22351 return resultobj;
22352 fail:
22353 return NULL;
22354 }
22355
22356
22357 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22358 PyObject *resultobj;
22359 wxDateTime *arg1 = (wxDateTime *) 0 ;
22360 wxDateTime *arg2 = 0 ;
22361 bool result;
22362 PyObject * obj0 = 0 ;
22363 PyObject * obj1 = 0 ;
22364 char *kwnames[] = {
22365 (char *) "self",(char *) "dt", NULL
22366 };
22367
22368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22370 if (SWIG_arg_fail(1)) SWIG_fail;
22371 {
22372 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22373 if (SWIG_arg_fail(2)) SWIG_fail;
22374 if (arg2 == NULL) {
22375 SWIG_null_ref("wxDateTime");
22376 }
22377 if (SWIG_arg_fail(2)) SWIG_fail;
22378 }
22379 {
22380 PyThreadState* __tstate = wxPyBeginAllowThreads();
22381 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22382
22383 wxPyEndAllowThreads(__tstate);
22384 if (PyErr_Occurred()) SWIG_fail;
22385 }
22386 {
22387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22388 }
22389 return resultobj;
22390 fail:
22391 return NULL;
22392 }
22393
22394
22395 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22396 PyObject *resultobj;
22397 wxDateTime *arg1 = (wxDateTime *) 0 ;
22398 wxDateTime *arg2 = 0 ;
22399 wxTimeSpan *arg3 = 0 ;
22400 bool result;
22401 PyObject * obj0 = 0 ;
22402 PyObject * obj1 = 0 ;
22403 PyObject * obj2 = 0 ;
22404 char *kwnames[] = {
22405 (char *) "self",(char *) "dt",(char *) "ts", NULL
22406 };
22407
22408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22410 if (SWIG_arg_fail(1)) SWIG_fail;
22411 {
22412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22413 if (SWIG_arg_fail(2)) SWIG_fail;
22414 if (arg2 == NULL) {
22415 SWIG_null_ref("wxDateTime");
22416 }
22417 if (SWIG_arg_fail(2)) SWIG_fail;
22418 }
22419 {
22420 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22421 if (SWIG_arg_fail(3)) SWIG_fail;
22422 if (arg3 == NULL) {
22423 SWIG_null_ref("wxTimeSpan");
22424 }
22425 if (SWIG_arg_fail(3)) SWIG_fail;
22426 }
22427 {
22428 PyThreadState* __tstate = wxPyBeginAllowThreads();
22429 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22430
22431 wxPyEndAllowThreads(__tstate);
22432 if (PyErr_Occurred()) SWIG_fail;
22433 }
22434 {
22435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22436 }
22437 return resultobj;
22438 fail:
22439 return NULL;
22440 }
22441
22442
22443 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22444 PyObject *resultobj;
22445 wxDateTime *arg1 = (wxDateTime *) 0 ;
22446 wxTimeSpan *arg2 = 0 ;
22447 wxDateTime *result;
22448 PyObject * obj0 = 0 ;
22449 PyObject * obj1 = 0 ;
22450 char *kwnames[] = {
22451 (char *) "self",(char *) "diff", NULL
22452 };
22453
22454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22456 if (SWIG_arg_fail(1)) SWIG_fail;
22457 {
22458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22459 if (SWIG_arg_fail(2)) SWIG_fail;
22460 if (arg2 == NULL) {
22461 SWIG_null_ref("wxTimeSpan");
22462 }
22463 if (SWIG_arg_fail(2)) SWIG_fail;
22464 }
22465 {
22466 PyThreadState* __tstate = wxPyBeginAllowThreads();
22467 {
22468 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22469 result = (wxDateTime *) &_result_ref;
22470 }
22471
22472 wxPyEndAllowThreads(__tstate);
22473 if (PyErr_Occurred()) SWIG_fail;
22474 }
22475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22476 return resultobj;
22477 fail:
22478 return NULL;
22479 }
22480
22481
22482 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22483 PyObject *resultobj;
22484 wxDateTime *arg1 = (wxDateTime *) 0 ;
22485 wxDateSpan *arg2 = 0 ;
22486 wxDateTime *result;
22487 PyObject * obj0 = 0 ;
22488 PyObject * obj1 = 0 ;
22489 char *kwnames[] = {
22490 (char *) "self",(char *) "diff", NULL
22491 };
22492
22493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22495 if (SWIG_arg_fail(1)) SWIG_fail;
22496 {
22497 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22498 if (SWIG_arg_fail(2)) SWIG_fail;
22499 if (arg2 == NULL) {
22500 SWIG_null_ref("wxDateSpan");
22501 }
22502 if (SWIG_arg_fail(2)) SWIG_fail;
22503 }
22504 {
22505 PyThreadState* __tstate = wxPyBeginAllowThreads();
22506 {
22507 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22508 result = (wxDateTime *) &_result_ref;
22509 }
22510
22511 wxPyEndAllowThreads(__tstate);
22512 if (PyErr_Occurred()) SWIG_fail;
22513 }
22514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22515 return resultobj;
22516 fail:
22517 return NULL;
22518 }
22519
22520
22521 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22522 PyObject *resultobj;
22523 wxDateTime *arg1 = (wxDateTime *) 0 ;
22524 wxTimeSpan *arg2 = 0 ;
22525 wxDateTime *result;
22526 PyObject * obj0 = 0 ;
22527 PyObject * obj1 = 0 ;
22528 char *kwnames[] = {
22529 (char *) "self",(char *) "diff", NULL
22530 };
22531
22532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22534 if (SWIG_arg_fail(1)) SWIG_fail;
22535 {
22536 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22537 if (SWIG_arg_fail(2)) SWIG_fail;
22538 if (arg2 == NULL) {
22539 SWIG_null_ref("wxTimeSpan");
22540 }
22541 if (SWIG_arg_fail(2)) SWIG_fail;
22542 }
22543 {
22544 PyThreadState* __tstate = wxPyBeginAllowThreads();
22545 {
22546 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22547 result = (wxDateTime *) &_result_ref;
22548 }
22549
22550 wxPyEndAllowThreads(__tstate);
22551 if (PyErr_Occurred()) SWIG_fail;
22552 }
22553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22554 return resultobj;
22555 fail:
22556 return NULL;
22557 }
22558
22559
22560 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22561 PyObject *resultobj;
22562 wxDateTime *arg1 = (wxDateTime *) 0 ;
22563 wxDateSpan *arg2 = 0 ;
22564 wxDateTime *result;
22565 PyObject * obj0 = 0 ;
22566 PyObject * obj1 = 0 ;
22567 char *kwnames[] = {
22568 (char *) "self",(char *) "diff", NULL
22569 };
22570
22571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22573 if (SWIG_arg_fail(1)) SWIG_fail;
22574 {
22575 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22576 if (SWIG_arg_fail(2)) SWIG_fail;
22577 if (arg2 == NULL) {
22578 SWIG_null_ref("wxDateSpan");
22579 }
22580 if (SWIG_arg_fail(2)) SWIG_fail;
22581 }
22582 {
22583 PyThreadState* __tstate = wxPyBeginAllowThreads();
22584 {
22585 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22586 result = (wxDateTime *) &_result_ref;
22587 }
22588
22589 wxPyEndAllowThreads(__tstate);
22590 if (PyErr_Occurred()) SWIG_fail;
22591 }
22592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22593 return resultobj;
22594 fail:
22595 return NULL;
22596 }
22597
22598
22599 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22600 PyObject *resultobj;
22601 wxDateTime *arg1 = (wxDateTime *) 0 ;
22602 wxDateTime *arg2 = 0 ;
22603 wxTimeSpan result;
22604 PyObject * obj0 = 0 ;
22605 PyObject * obj1 = 0 ;
22606 char *kwnames[] = {
22607 (char *) "self",(char *) "dt", NULL
22608 };
22609
22610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22612 if (SWIG_arg_fail(1)) SWIG_fail;
22613 {
22614 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22615 if (SWIG_arg_fail(2)) SWIG_fail;
22616 if (arg2 == NULL) {
22617 SWIG_null_ref("wxDateTime");
22618 }
22619 if (SWIG_arg_fail(2)) SWIG_fail;
22620 }
22621 {
22622 PyThreadState* __tstate = wxPyBeginAllowThreads();
22623 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22624
22625 wxPyEndAllowThreads(__tstate);
22626 if (PyErr_Occurred()) SWIG_fail;
22627 }
22628 {
22629 wxTimeSpan * resultptr;
22630 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22631 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22632 }
22633 return resultobj;
22634 fail:
22635 return NULL;
22636 }
22637
22638
22639 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22640 PyObject *resultobj;
22641 wxDateTime *arg1 = (wxDateTime *) 0 ;
22642 wxTimeSpan *arg2 = 0 ;
22643 wxDateTime *result;
22644 PyObject * obj0 = 0 ;
22645 PyObject * obj1 = 0 ;
22646
22647 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22649 if (SWIG_arg_fail(1)) SWIG_fail;
22650 {
22651 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22652 if (SWIG_arg_fail(2)) SWIG_fail;
22653 if (arg2 == NULL) {
22654 SWIG_null_ref("wxTimeSpan");
22655 }
22656 if (SWIG_arg_fail(2)) SWIG_fail;
22657 }
22658 {
22659 PyThreadState* __tstate = wxPyBeginAllowThreads();
22660 {
22661 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22662 result = (wxDateTime *) &_result_ref;
22663 }
22664
22665 wxPyEndAllowThreads(__tstate);
22666 if (PyErr_Occurred()) SWIG_fail;
22667 }
22668 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22669 return resultobj;
22670 fail:
22671 return NULL;
22672 }
22673
22674
22675 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22676 PyObject *resultobj;
22677 wxDateTime *arg1 = (wxDateTime *) 0 ;
22678 wxDateSpan *arg2 = 0 ;
22679 wxDateTime *result;
22680 PyObject * obj0 = 0 ;
22681 PyObject * obj1 = 0 ;
22682
22683 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22685 if (SWIG_arg_fail(1)) SWIG_fail;
22686 {
22687 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22688 if (SWIG_arg_fail(2)) SWIG_fail;
22689 if (arg2 == NULL) {
22690 SWIG_null_ref("wxDateSpan");
22691 }
22692 if (SWIG_arg_fail(2)) SWIG_fail;
22693 }
22694 {
22695 PyThreadState* __tstate = wxPyBeginAllowThreads();
22696 {
22697 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22698 result = (wxDateTime *) &_result_ref;
22699 }
22700
22701 wxPyEndAllowThreads(__tstate);
22702 if (PyErr_Occurred()) SWIG_fail;
22703 }
22704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22705 return resultobj;
22706 fail:
22707 return NULL;
22708 }
22709
22710
22711 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22712 int argc;
22713 PyObject *argv[3];
22714 int ii;
22715
22716 argc = PyObject_Length(args);
22717 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22718 argv[ii] = PyTuple_GetItem(args,ii);
22719 }
22720 if (argc == 2) {
22721 int _v;
22722 {
22723 void *ptr;
22724 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22725 _v = 0;
22726 PyErr_Clear();
22727 } else {
22728 _v = 1;
22729 }
22730 }
22731 if (_v) {
22732 {
22733 void *ptr = 0;
22734 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22735 _v = 0;
22736 PyErr_Clear();
22737 } else {
22738 _v = (ptr != 0);
22739 }
22740 }
22741 if (_v) {
22742 return _wrap_DateTime___iadd____SWIG_0(self,args);
22743 }
22744 }
22745 }
22746 if (argc == 2) {
22747 int _v;
22748 {
22749 void *ptr;
22750 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22751 _v = 0;
22752 PyErr_Clear();
22753 } else {
22754 _v = 1;
22755 }
22756 }
22757 if (_v) {
22758 {
22759 void *ptr = 0;
22760 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22761 _v = 0;
22762 PyErr_Clear();
22763 } else {
22764 _v = (ptr != 0);
22765 }
22766 }
22767 if (_v) {
22768 return _wrap_DateTime___iadd____SWIG_1(self,args);
22769 }
22770 }
22771 }
22772
22773 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22774 return NULL;
22775 }
22776
22777
22778 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22779 PyObject *resultobj;
22780 wxDateTime *arg1 = (wxDateTime *) 0 ;
22781 wxTimeSpan *arg2 = 0 ;
22782 wxDateTime *result;
22783 PyObject * obj0 = 0 ;
22784 PyObject * obj1 = 0 ;
22785
22786 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22788 if (SWIG_arg_fail(1)) SWIG_fail;
22789 {
22790 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22791 if (SWIG_arg_fail(2)) SWIG_fail;
22792 if (arg2 == NULL) {
22793 SWIG_null_ref("wxTimeSpan");
22794 }
22795 if (SWIG_arg_fail(2)) SWIG_fail;
22796 }
22797 {
22798 PyThreadState* __tstate = wxPyBeginAllowThreads();
22799 {
22800 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22801 result = (wxDateTime *) &_result_ref;
22802 }
22803
22804 wxPyEndAllowThreads(__tstate);
22805 if (PyErr_Occurred()) SWIG_fail;
22806 }
22807 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22808 return resultobj;
22809 fail:
22810 return NULL;
22811 }
22812
22813
22814 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22815 PyObject *resultobj;
22816 wxDateTime *arg1 = (wxDateTime *) 0 ;
22817 wxDateSpan *arg2 = 0 ;
22818 wxDateTime *result;
22819 PyObject * obj0 = 0 ;
22820 PyObject * obj1 = 0 ;
22821
22822 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22824 if (SWIG_arg_fail(1)) SWIG_fail;
22825 {
22826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22827 if (SWIG_arg_fail(2)) SWIG_fail;
22828 if (arg2 == NULL) {
22829 SWIG_null_ref("wxDateSpan");
22830 }
22831 if (SWIG_arg_fail(2)) SWIG_fail;
22832 }
22833 {
22834 PyThreadState* __tstate = wxPyBeginAllowThreads();
22835 {
22836 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22837 result = (wxDateTime *) &_result_ref;
22838 }
22839
22840 wxPyEndAllowThreads(__tstate);
22841 if (PyErr_Occurred()) SWIG_fail;
22842 }
22843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22844 return resultobj;
22845 fail:
22846 return NULL;
22847 }
22848
22849
22850 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22851 int argc;
22852 PyObject *argv[3];
22853 int ii;
22854
22855 argc = PyObject_Length(args);
22856 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22857 argv[ii] = PyTuple_GetItem(args,ii);
22858 }
22859 if (argc == 2) {
22860 int _v;
22861 {
22862 void *ptr;
22863 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22864 _v = 0;
22865 PyErr_Clear();
22866 } else {
22867 _v = 1;
22868 }
22869 }
22870 if (_v) {
22871 {
22872 void *ptr = 0;
22873 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22874 _v = 0;
22875 PyErr_Clear();
22876 } else {
22877 _v = (ptr != 0);
22878 }
22879 }
22880 if (_v) {
22881 return _wrap_DateTime___isub____SWIG_0(self,args);
22882 }
22883 }
22884 }
22885 if (argc == 2) {
22886 int _v;
22887 {
22888 void *ptr;
22889 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22890 _v = 0;
22891 PyErr_Clear();
22892 } else {
22893 _v = 1;
22894 }
22895 }
22896 if (_v) {
22897 {
22898 void *ptr = 0;
22899 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22900 _v = 0;
22901 PyErr_Clear();
22902 } else {
22903 _v = (ptr != 0);
22904 }
22905 }
22906 if (_v) {
22907 return _wrap_DateTime___isub____SWIG_1(self,args);
22908 }
22909 }
22910 }
22911
22912 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22913 return NULL;
22914 }
22915
22916
22917 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22918 PyObject *resultobj;
22919 wxDateTime *arg1 = (wxDateTime *) 0 ;
22920 wxTimeSpan *arg2 = 0 ;
22921 wxDateTime result;
22922 PyObject * obj0 = 0 ;
22923 PyObject * obj1 = 0 ;
22924
22925 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22927 if (SWIG_arg_fail(1)) SWIG_fail;
22928 {
22929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22930 if (SWIG_arg_fail(2)) SWIG_fail;
22931 if (arg2 == NULL) {
22932 SWIG_null_ref("wxTimeSpan");
22933 }
22934 if (SWIG_arg_fail(2)) SWIG_fail;
22935 }
22936 {
22937 PyThreadState* __tstate = wxPyBeginAllowThreads();
22938 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22939
22940 wxPyEndAllowThreads(__tstate);
22941 if (PyErr_Occurred()) SWIG_fail;
22942 }
22943 {
22944 wxDateTime * resultptr;
22945 resultptr = new wxDateTime((wxDateTime &)(result));
22946 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22947 }
22948 return resultobj;
22949 fail:
22950 return NULL;
22951 }
22952
22953
22954 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22955 PyObject *resultobj;
22956 wxDateTime *arg1 = (wxDateTime *) 0 ;
22957 wxDateSpan *arg2 = 0 ;
22958 wxDateTime result;
22959 PyObject * obj0 = 0 ;
22960 PyObject * obj1 = 0 ;
22961
22962 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22964 if (SWIG_arg_fail(1)) SWIG_fail;
22965 {
22966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22967 if (SWIG_arg_fail(2)) SWIG_fail;
22968 if (arg2 == NULL) {
22969 SWIG_null_ref("wxDateSpan");
22970 }
22971 if (SWIG_arg_fail(2)) SWIG_fail;
22972 }
22973 {
22974 PyThreadState* __tstate = wxPyBeginAllowThreads();
22975 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22976
22977 wxPyEndAllowThreads(__tstate);
22978 if (PyErr_Occurred()) SWIG_fail;
22979 }
22980 {
22981 wxDateTime * resultptr;
22982 resultptr = new wxDateTime((wxDateTime &)(result));
22983 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22984 }
22985 return resultobj;
22986 fail:
22987 return NULL;
22988 }
22989
22990
22991 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22992 int argc;
22993 PyObject *argv[3];
22994 int ii;
22995
22996 argc = PyObject_Length(args);
22997 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22998 argv[ii] = PyTuple_GetItem(args,ii);
22999 }
23000 if (argc == 2) {
23001 int _v;
23002 {
23003 void *ptr;
23004 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23005 _v = 0;
23006 PyErr_Clear();
23007 } else {
23008 _v = 1;
23009 }
23010 }
23011 if (_v) {
23012 {
23013 void *ptr = 0;
23014 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23015 _v = 0;
23016 PyErr_Clear();
23017 } else {
23018 _v = (ptr != 0);
23019 }
23020 }
23021 if (_v) {
23022 return _wrap_DateTime___add____SWIG_0(self,args);
23023 }
23024 }
23025 }
23026 if (argc == 2) {
23027 int _v;
23028 {
23029 void *ptr;
23030 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23031 _v = 0;
23032 PyErr_Clear();
23033 } else {
23034 _v = 1;
23035 }
23036 }
23037 if (_v) {
23038 {
23039 void *ptr = 0;
23040 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23041 _v = 0;
23042 PyErr_Clear();
23043 } else {
23044 _v = (ptr != 0);
23045 }
23046 }
23047 if (_v) {
23048 return _wrap_DateTime___add____SWIG_1(self,args);
23049 }
23050 }
23051 }
23052
23053 Py_INCREF(Py_NotImplemented);
23054 return Py_NotImplemented;
23055 }
23056
23057
23058 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23059 PyObject *resultobj;
23060 wxDateTime *arg1 = (wxDateTime *) 0 ;
23061 wxDateTime *arg2 = 0 ;
23062 wxTimeSpan result;
23063 PyObject * obj0 = 0 ;
23064 PyObject * obj1 = 0 ;
23065
23066 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23068 if (SWIG_arg_fail(1)) SWIG_fail;
23069 {
23070 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23071 if (SWIG_arg_fail(2)) SWIG_fail;
23072 if (arg2 == NULL) {
23073 SWIG_null_ref("wxDateTime");
23074 }
23075 if (SWIG_arg_fail(2)) SWIG_fail;
23076 }
23077 {
23078 PyThreadState* __tstate = wxPyBeginAllowThreads();
23079 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23080
23081 wxPyEndAllowThreads(__tstate);
23082 if (PyErr_Occurred()) SWIG_fail;
23083 }
23084 {
23085 wxTimeSpan * resultptr;
23086 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23087 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23088 }
23089 return resultobj;
23090 fail:
23091 return NULL;
23092 }
23093
23094
23095 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23096 PyObject *resultobj;
23097 wxDateTime *arg1 = (wxDateTime *) 0 ;
23098 wxTimeSpan *arg2 = 0 ;
23099 wxDateTime result;
23100 PyObject * obj0 = 0 ;
23101 PyObject * obj1 = 0 ;
23102
23103 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23105 if (SWIG_arg_fail(1)) SWIG_fail;
23106 {
23107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23108 if (SWIG_arg_fail(2)) SWIG_fail;
23109 if (arg2 == NULL) {
23110 SWIG_null_ref("wxTimeSpan");
23111 }
23112 if (SWIG_arg_fail(2)) SWIG_fail;
23113 }
23114 {
23115 PyThreadState* __tstate = wxPyBeginAllowThreads();
23116 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23117
23118 wxPyEndAllowThreads(__tstate);
23119 if (PyErr_Occurred()) SWIG_fail;
23120 }
23121 {
23122 wxDateTime * resultptr;
23123 resultptr = new wxDateTime((wxDateTime &)(result));
23124 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23125 }
23126 return resultobj;
23127 fail:
23128 return NULL;
23129 }
23130
23131
23132 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23133 PyObject *resultobj;
23134 wxDateTime *arg1 = (wxDateTime *) 0 ;
23135 wxDateSpan *arg2 = 0 ;
23136 wxDateTime result;
23137 PyObject * obj0 = 0 ;
23138 PyObject * obj1 = 0 ;
23139
23140 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23142 if (SWIG_arg_fail(1)) SWIG_fail;
23143 {
23144 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23145 if (SWIG_arg_fail(2)) SWIG_fail;
23146 if (arg2 == NULL) {
23147 SWIG_null_ref("wxDateSpan");
23148 }
23149 if (SWIG_arg_fail(2)) SWIG_fail;
23150 }
23151 {
23152 PyThreadState* __tstate = wxPyBeginAllowThreads();
23153 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23154
23155 wxPyEndAllowThreads(__tstate);
23156 if (PyErr_Occurred()) SWIG_fail;
23157 }
23158 {
23159 wxDateTime * resultptr;
23160 resultptr = new wxDateTime((wxDateTime &)(result));
23161 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23162 }
23163 return resultobj;
23164 fail:
23165 return NULL;
23166 }
23167
23168
23169 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23170 int argc;
23171 PyObject *argv[3];
23172 int ii;
23173
23174 argc = PyObject_Length(args);
23175 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23176 argv[ii] = PyTuple_GetItem(args,ii);
23177 }
23178 if (argc == 2) {
23179 int _v;
23180 {
23181 void *ptr;
23182 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23183 _v = 0;
23184 PyErr_Clear();
23185 } else {
23186 _v = 1;
23187 }
23188 }
23189 if (_v) {
23190 {
23191 void *ptr = 0;
23192 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23193 _v = 0;
23194 PyErr_Clear();
23195 } else {
23196 _v = (ptr != 0);
23197 }
23198 }
23199 if (_v) {
23200 return _wrap_DateTime___sub____SWIG_0(self,args);
23201 }
23202 }
23203 }
23204 if (argc == 2) {
23205 int _v;
23206 {
23207 void *ptr;
23208 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23209 _v = 0;
23210 PyErr_Clear();
23211 } else {
23212 _v = 1;
23213 }
23214 }
23215 if (_v) {
23216 {
23217 void *ptr = 0;
23218 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23219 _v = 0;
23220 PyErr_Clear();
23221 } else {
23222 _v = (ptr != 0);
23223 }
23224 }
23225 if (_v) {
23226 return _wrap_DateTime___sub____SWIG_1(self,args);
23227 }
23228 }
23229 }
23230 if (argc == 2) {
23231 int _v;
23232 {
23233 void *ptr;
23234 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23235 _v = 0;
23236 PyErr_Clear();
23237 } else {
23238 _v = 1;
23239 }
23240 }
23241 if (_v) {
23242 {
23243 void *ptr = 0;
23244 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23245 _v = 0;
23246 PyErr_Clear();
23247 } else {
23248 _v = (ptr != 0);
23249 }
23250 }
23251 if (_v) {
23252 return _wrap_DateTime___sub____SWIG_2(self,args);
23253 }
23254 }
23255 }
23256
23257 Py_INCREF(Py_NotImplemented);
23258 return Py_NotImplemented;
23259 }
23260
23261
23262 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23263 PyObject *resultobj;
23264 wxDateTime *arg1 = (wxDateTime *) 0 ;
23265 wxDateTime *arg2 = (wxDateTime *) 0 ;
23266 bool result;
23267 PyObject * obj0 = 0 ;
23268 PyObject * obj1 = 0 ;
23269 char *kwnames[] = {
23270 (char *) "self",(char *) "other", NULL
23271 };
23272
23273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23275 if (SWIG_arg_fail(1)) SWIG_fail;
23276 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23277 if (SWIG_arg_fail(2)) SWIG_fail;
23278 {
23279 PyThreadState* __tstate = wxPyBeginAllowThreads();
23280 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23281
23282 wxPyEndAllowThreads(__tstate);
23283 if (PyErr_Occurred()) SWIG_fail;
23284 }
23285 {
23286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23287 }
23288 return resultobj;
23289 fail:
23290 return NULL;
23291 }
23292
23293
23294 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23295 PyObject *resultobj;
23296 wxDateTime *arg1 = (wxDateTime *) 0 ;
23297 wxDateTime *arg2 = (wxDateTime *) 0 ;
23298 bool result;
23299 PyObject * obj0 = 0 ;
23300 PyObject * obj1 = 0 ;
23301 char *kwnames[] = {
23302 (char *) "self",(char *) "other", NULL
23303 };
23304
23305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23307 if (SWIG_arg_fail(1)) SWIG_fail;
23308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23309 if (SWIG_arg_fail(2)) SWIG_fail;
23310 {
23311 PyThreadState* __tstate = wxPyBeginAllowThreads();
23312 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23313
23314 wxPyEndAllowThreads(__tstate);
23315 if (PyErr_Occurred()) SWIG_fail;
23316 }
23317 {
23318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23319 }
23320 return resultobj;
23321 fail:
23322 return NULL;
23323 }
23324
23325
23326 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23327 PyObject *resultobj;
23328 wxDateTime *arg1 = (wxDateTime *) 0 ;
23329 wxDateTime *arg2 = (wxDateTime *) 0 ;
23330 bool result;
23331 PyObject * obj0 = 0 ;
23332 PyObject * obj1 = 0 ;
23333 char *kwnames[] = {
23334 (char *) "self",(char *) "other", NULL
23335 };
23336
23337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23339 if (SWIG_arg_fail(1)) SWIG_fail;
23340 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23341 if (SWIG_arg_fail(2)) SWIG_fail;
23342 {
23343 PyThreadState* __tstate = wxPyBeginAllowThreads();
23344 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23345
23346 wxPyEndAllowThreads(__tstate);
23347 if (PyErr_Occurred()) SWIG_fail;
23348 }
23349 {
23350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23351 }
23352 return resultobj;
23353 fail:
23354 return NULL;
23355 }
23356
23357
23358 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23359 PyObject *resultobj;
23360 wxDateTime *arg1 = (wxDateTime *) 0 ;
23361 wxDateTime *arg2 = (wxDateTime *) 0 ;
23362 bool result;
23363 PyObject * obj0 = 0 ;
23364 PyObject * obj1 = 0 ;
23365 char *kwnames[] = {
23366 (char *) "self",(char *) "other", NULL
23367 };
23368
23369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23371 if (SWIG_arg_fail(1)) SWIG_fail;
23372 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23373 if (SWIG_arg_fail(2)) SWIG_fail;
23374 {
23375 PyThreadState* __tstate = wxPyBeginAllowThreads();
23376 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23377
23378 wxPyEndAllowThreads(__tstate);
23379 if (PyErr_Occurred()) SWIG_fail;
23380 }
23381 {
23382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23383 }
23384 return resultobj;
23385 fail:
23386 return NULL;
23387 }
23388
23389
23390 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23391 PyObject *resultobj;
23392 wxDateTime *arg1 = (wxDateTime *) 0 ;
23393 wxDateTime *arg2 = (wxDateTime *) 0 ;
23394 bool result;
23395 PyObject * obj0 = 0 ;
23396 PyObject * obj1 = 0 ;
23397 char *kwnames[] = {
23398 (char *) "self",(char *) "other", NULL
23399 };
23400
23401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23403 if (SWIG_arg_fail(1)) SWIG_fail;
23404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23405 if (SWIG_arg_fail(2)) SWIG_fail;
23406 {
23407 PyThreadState* __tstate = wxPyBeginAllowThreads();
23408 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23409
23410 wxPyEndAllowThreads(__tstate);
23411 if (PyErr_Occurred()) SWIG_fail;
23412 }
23413 {
23414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23415 }
23416 return resultobj;
23417 fail:
23418 return NULL;
23419 }
23420
23421
23422 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23423 PyObject *resultobj;
23424 wxDateTime *arg1 = (wxDateTime *) 0 ;
23425 wxDateTime *arg2 = (wxDateTime *) 0 ;
23426 bool result;
23427 PyObject * obj0 = 0 ;
23428 PyObject * obj1 = 0 ;
23429 char *kwnames[] = {
23430 (char *) "self",(char *) "other", NULL
23431 };
23432
23433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23435 if (SWIG_arg_fail(1)) SWIG_fail;
23436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23437 if (SWIG_arg_fail(2)) SWIG_fail;
23438 {
23439 PyThreadState* __tstate = wxPyBeginAllowThreads();
23440 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23441
23442 wxPyEndAllowThreads(__tstate);
23443 if (PyErr_Occurred()) SWIG_fail;
23444 }
23445 {
23446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23447 }
23448 return resultobj;
23449 fail:
23450 return NULL;
23451 }
23452
23453
23454 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23455 PyObject *resultobj;
23456 wxDateTime *arg1 = (wxDateTime *) 0 ;
23457 wxString *arg2 = 0 ;
23458 int result;
23459 bool temp2 = false ;
23460 PyObject * obj0 = 0 ;
23461 PyObject * obj1 = 0 ;
23462 char *kwnames[] = {
23463 (char *) "self",(char *) "date", NULL
23464 };
23465
23466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23468 if (SWIG_arg_fail(1)) SWIG_fail;
23469 {
23470 arg2 = wxString_in_helper(obj1);
23471 if (arg2 == NULL) SWIG_fail;
23472 temp2 = true;
23473 }
23474 {
23475 PyThreadState* __tstate = wxPyBeginAllowThreads();
23476 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23477
23478 wxPyEndAllowThreads(__tstate);
23479 if (PyErr_Occurred()) SWIG_fail;
23480 }
23481 {
23482 resultobj = SWIG_From_int((int)(result));
23483 }
23484 {
23485 if (temp2)
23486 delete arg2;
23487 }
23488 return resultobj;
23489 fail:
23490 {
23491 if (temp2)
23492 delete arg2;
23493 }
23494 return NULL;
23495 }
23496
23497
23498 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23499 PyObject *resultobj;
23500 wxDateTime *arg1 = (wxDateTime *) 0 ;
23501 wxString *arg2 = 0 ;
23502 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23503 wxString *arg3 = (wxString *) &arg3_defvalue ;
23504 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23505 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23506 int result;
23507 bool temp2 = false ;
23508 bool temp3 = false ;
23509 PyObject * obj0 = 0 ;
23510 PyObject * obj1 = 0 ;
23511 PyObject * obj2 = 0 ;
23512 PyObject * obj3 = 0 ;
23513 char *kwnames[] = {
23514 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23515 };
23516
23517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23519 if (SWIG_arg_fail(1)) SWIG_fail;
23520 {
23521 arg2 = wxString_in_helper(obj1);
23522 if (arg2 == NULL) SWIG_fail;
23523 temp2 = true;
23524 }
23525 if (obj2) {
23526 {
23527 arg3 = wxString_in_helper(obj2);
23528 if (arg3 == NULL) SWIG_fail;
23529 temp3 = true;
23530 }
23531 }
23532 if (obj3) {
23533 {
23534 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23535 if (SWIG_arg_fail(4)) SWIG_fail;
23536 if (arg4 == NULL) {
23537 SWIG_null_ref("wxDateTime");
23538 }
23539 if (SWIG_arg_fail(4)) SWIG_fail;
23540 }
23541 }
23542 {
23543 PyThreadState* __tstate = wxPyBeginAllowThreads();
23544 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23545
23546 wxPyEndAllowThreads(__tstate);
23547 if (PyErr_Occurred()) SWIG_fail;
23548 }
23549 {
23550 resultobj = SWIG_From_int((int)(result));
23551 }
23552 {
23553 if (temp2)
23554 delete arg2;
23555 }
23556 {
23557 if (temp3)
23558 delete arg3;
23559 }
23560 return resultobj;
23561 fail:
23562 {
23563 if (temp2)
23564 delete arg2;
23565 }
23566 {
23567 if (temp3)
23568 delete arg3;
23569 }
23570 return NULL;
23571 }
23572
23573
23574 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23575 PyObject *resultobj;
23576 wxDateTime *arg1 = (wxDateTime *) 0 ;
23577 wxString *arg2 = 0 ;
23578 int result;
23579 bool temp2 = false ;
23580 PyObject * obj0 = 0 ;
23581 PyObject * obj1 = 0 ;
23582 char *kwnames[] = {
23583 (char *) "self",(char *) "datetime", NULL
23584 };
23585
23586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23588 if (SWIG_arg_fail(1)) SWIG_fail;
23589 {
23590 arg2 = wxString_in_helper(obj1);
23591 if (arg2 == NULL) SWIG_fail;
23592 temp2 = true;
23593 }
23594 {
23595 PyThreadState* __tstate = wxPyBeginAllowThreads();
23596 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23597
23598 wxPyEndAllowThreads(__tstate);
23599 if (PyErr_Occurred()) SWIG_fail;
23600 }
23601 {
23602 resultobj = SWIG_From_int((int)(result));
23603 }
23604 {
23605 if (temp2)
23606 delete arg2;
23607 }
23608 return resultobj;
23609 fail:
23610 {
23611 if (temp2)
23612 delete arg2;
23613 }
23614 return NULL;
23615 }
23616
23617
23618 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23619 PyObject *resultobj;
23620 wxDateTime *arg1 = (wxDateTime *) 0 ;
23621 wxString *arg2 = 0 ;
23622 int result;
23623 bool temp2 = false ;
23624 PyObject * obj0 = 0 ;
23625 PyObject * obj1 = 0 ;
23626 char *kwnames[] = {
23627 (char *) "self",(char *) "date", NULL
23628 };
23629
23630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23632 if (SWIG_arg_fail(1)) SWIG_fail;
23633 {
23634 arg2 = wxString_in_helper(obj1);
23635 if (arg2 == NULL) SWIG_fail;
23636 temp2 = true;
23637 }
23638 {
23639 PyThreadState* __tstate = wxPyBeginAllowThreads();
23640 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23641
23642 wxPyEndAllowThreads(__tstate);
23643 if (PyErr_Occurred()) SWIG_fail;
23644 }
23645 {
23646 resultobj = SWIG_From_int((int)(result));
23647 }
23648 {
23649 if (temp2)
23650 delete arg2;
23651 }
23652 return resultobj;
23653 fail:
23654 {
23655 if (temp2)
23656 delete arg2;
23657 }
23658 return NULL;
23659 }
23660
23661
23662 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23663 PyObject *resultobj;
23664 wxDateTime *arg1 = (wxDateTime *) 0 ;
23665 wxString *arg2 = 0 ;
23666 int result;
23667 bool temp2 = false ;
23668 PyObject * obj0 = 0 ;
23669 PyObject * obj1 = 0 ;
23670 char *kwnames[] = {
23671 (char *) "self",(char *) "time", NULL
23672 };
23673
23674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23676 if (SWIG_arg_fail(1)) SWIG_fail;
23677 {
23678 arg2 = wxString_in_helper(obj1);
23679 if (arg2 == NULL) SWIG_fail;
23680 temp2 = true;
23681 }
23682 {
23683 PyThreadState* __tstate = wxPyBeginAllowThreads();
23684 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23685
23686 wxPyEndAllowThreads(__tstate);
23687 if (PyErr_Occurred()) SWIG_fail;
23688 }
23689 {
23690 resultobj = SWIG_From_int((int)(result));
23691 }
23692 {
23693 if (temp2)
23694 delete arg2;
23695 }
23696 return resultobj;
23697 fail:
23698 {
23699 if (temp2)
23700 delete arg2;
23701 }
23702 return NULL;
23703 }
23704
23705
23706 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23707 PyObject *resultobj;
23708 wxDateTime *arg1 = (wxDateTime *) 0 ;
23709 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23710 wxString *arg2 = (wxString *) &arg2_defvalue ;
23711 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23712 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23713 wxString result;
23714 bool temp2 = false ;
23715 bool temp3 = false ;
23716 PyObject * obj0 = 0 ;
23717 PyObject * obj1 = 0 ;
23718 PyObject * obj2 = 0 ;
23719 char *kwnames[] = {
23720 (char *) "self",(char *) "format",(char *) "tz", NULL
23721 };
23722
23723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) 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 if (obj1) {
23727 {
23728 arg2 = wxString_in_helper(obj1);
23729 if (arg2 == NULL) SWIG_fail;
23730 temp2 = true;
23731 }
23732 }
23733 if (obj2) {
23734 {
23735 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23736 temp3 = true;
23737 }
23738 }
23739 {
23740 PyThreadState* __tstate = wxPyBeginAllowThreads();
23741 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23742
23743 wxPyEndAllowThreads(__tstate);
23744 if (PyErr_Occurred()) SWIG_fail;
23745 }
23746 {
23747 #if wxUSE_UNICODE
23748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23749 #else
23750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23751 #endif
23752 }
23753 {
23754 if (temp2)
23755 delete arg2;
23756 }
23757 {
23758 if (temp3) delete arg3;
23759 }
23760 return resultobj;
23761 fail:
23762 {
23763 if (temp2)
23764 delete arg2;
23765 }
23766 {
23767 if (temp3) delete arg3;
23768 }
23769 return NULL;
23770 }
23771
23772
23773 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23774 PyObject *resultobj;
23775 wxDateTime *arg1 = (wxDateTime *) 0 ;
23776 wxString result;
23777 PyObject * obj0 = 0 ;
23778 char *kwnames[] = {
23779 (char *) "self", NULL
23780 };
23781
23782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23784 if (SWIG_arg_fail(1)) SWIG_fail;
23785 {
23786 PyThreadState* __tstate = wxPyBeginAllowThreads();
23787 result = ((wxDateTime const *)arg1)->FormatDate();
23788
23789 wxPyEndAllowThreads(__tstate);
23790 if (PyErr_Occurred()) SWIG_fail;
23791 }
23792 {
23793 #if wxUSE_UNICODE
23794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23795 #else
23796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23797 #endif
23798 }
23799 return resultobj;
23800 fail:
23801 return NULL;
23802 }
23803
23804
23805 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23806 PyObject *resultobj;
23807 wxDateTime *arg1 = (wxDateTime *) 0 ;
23808 wxString result;
23809 PyObject * obj0 = 0 ;
23810 char *kwnames[] = {
23811 (char *) "self", NULL
23812 };
23813
23814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23816 if (SWIG_arg_fail(1)) SWIG_fail;
23817 {
23818 PyThreadState* __tstate = wxPyBeginAllowThreads();
23819 result = ((wxDateTime const *)arg1)->FormatTime();
23820
23821 wxPyEndAllowThreads(__tstate);
23822 if (PyErr_Occurred()) SWIG_fail;
23823 }
23824 {
23825 #if wxUSE_UNICODE
23826 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23827 #else
23828 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23829 #endif
23830 }
23831 return resultobj;
23832 fail:
23833 return NULL;
23834 }
23835
23836
23837 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23838 PyObject *resultobj;
23839 wxDateTime *arg1 = (wxDateTime *) 0 ;
23840 wxString result;
23841 PyObject * obj0 = 0 ;
23842 char *kwnames[] = {
23843 (char *) "self", NULL
23844 };
23845
23846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23848 if (SWIG_arg_fail(1)) SWIG_fail;
23849 {
23850 PyThreadState* __tstate = wxPyBeginAllowThreads();
23851 result = ((wxDateTime const *)arg1)->FormatISODate();
23852
23853 wxPyEndAllowThreads(__tstate);
23854 if (PyErr_Occurred()) SWIG_fail;
23855 }
23856 {
23857 #if wxUSE_UNICODE
23858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23859 #else
23860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23861 #endif
23862 }
23863 return resultobj;
23864 fail:
23865 return NULL;
23866 }
23867
23868
23869 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23870 PyObject *resultobj;
23871 wxDateTime *arg1 = (wxDateTime *) 0 ;
23872 wxString result;
23873 PyObject * obj0 = 0 ;
23874 char *kwnames[] = {
23875 (char *) "self", NULL
23876 };
23877
23878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23880 if (SWIG_arg_fail(1)) SWIG_fail;
23881 {
23882 PyThreadState* __tstate = wxPyBeginAllowThreads();
23883 result = ((wxDateTime const *)arg1)->FormatISOTime();
23884
23885 wxPyEndAllowThreads(__tstate);
23886 if (PyErr_Occurred()) SWIG_fail;
23887 }
23888 {
23889 #if wxUSE_UNICODE
23890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23891 #else
23892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23893 #endif
23894 }
23895 return resultobj;
23896 fail:
23897 return NULL;
23898 }
23899
23900
23901 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23902 PyObject *obj;
23903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23904 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23905 Py_INCREF(obj);
23906 return Py_BuildValue((char *)"");
23907 }
23908 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23909 PyObject *resultobj;
23910 long arg1 ;
23911 wxTimeSpan result;
23912 PyObject * obj0 = 0 ;
23913 char *kwnames[] = {
23914 (char *) "sec", NULL
23915 };
23916
23917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23918 {
23919 arg1 = (long)(SWIG_As_long(obj0));
23920 if (SWIG_arg_fail(1)) SWIG_fail;
23921 }
23922 {
23923 PyThreadState* __tstate = wxPyBeginAllowThreads();
23924 result = wxTimeSpan::Seconds(arg1);
23925
23926 wxPyEndAllowThreads(__tstate);
23927 if (PyErr_Occurred()) SWIG_fail;
23928 }
23929 {
23930 wxTimeSpan * resultptr;
23931 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23932 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23933 }
23934 return resultobj;
23935 fail:
23936 return NULL;
23937 }
23938
23939
23940 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23941 PyObject *resultobj;
23942 wxTimeSpan result;
23943 char *kwnames[] = {
23944 NULL
23945 };
23946
23947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23948 {
23949 PyThreadState* __tstate = wxPyBeginAllowThreads();
23950 result = wxTimeSpan::Second();
23951
23952 wxPyEndAllowThreads(__tstate);
23953 if (PyErr_Occurred()) SWIG_fail;
23954 }
23955 {
23956 wxTimeSpan * resultptr;
23957 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23958 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23959 }
23960 return resultobj;
23961 fail:
23962 return NULL;
23963 }
23964
23965
23966 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23967 PyObject *resultobj;
23968 long arg1 ;
23969 wxTimeSpan result;
23970 PyObject * obj0 = 0 ;
23971 char *kwnames[] = {
23972 (char *) "min", NULL
23973 };
23974
23975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23976 {
23977 arg1 = (long)(SWIG_As_long(obj0));
23978 if (SWIG_arg_fail(1)) SWIG_fail;
23979 }
23980 {
23981 PyThreadState* __tstate = wxPyBeginAllowThreads();
23982 result = wxTimeSpan::Minutes(arg1);
23983
23984 wxPyEndAllowThreads(__tstate);
23985 if (PyErr_Occurred()) SWIG_fail;
23986 }
23987 {
23988 wxTimeSpan * resultptr;
23989 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23990 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23991 }
23992 return resultobj;
23993 fail:
23994 return NULL;
23995 }
23996
23997
23998 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23999 PyObject *resultobj;
24000 wxTimeSpan result;
24001 char *kwnames[] = {
24002 NULL
24003 };
24004
24005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = wxTimeSpan::Minute();
24009
24010 wxPyEndAllowThreads(__tstate);
24011 if (PyErr_Occurred()) SWIG_fail;
24012 }
24013 {
24014 wxTimeSpan * resultptr;
24015 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24016 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24017 }
24018 return resultobj;
24019 fail:
24020 return NULL;
24021 }
24022
24023
24024 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
24025 PyObject *resultobj;
24026 long arg1 ;
24027 wxTimeSpan result;
24028 PyObject * obj0 = 0 ;
24029 char *kwnames[] = {
24030 (char *) "hours", NULL
24031 };
24032
24033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
24034 {
24035 arg1 = (long)(SWIG_As_long(obj0));
24036 if (SWIG_arg_fail(1)) SWIG_fail;
24037 }
24038 {
24039 PyThreadState* __tstate = wxPyBeginAllowThreads();
24040 result = wxTimeSpan::Hours(arg1);
24041
24042 wxPyEndAllowThreads(__tstate);
24043 if (PyErr_Occurred()) SWIG_fail;
24044 }
24045 {
24046 wxTimeSpan * resultptr;
24047 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24048 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24049 }
24050 return resultobj;
24051 fail:
24052 return NULL;
24053 }
24054
24055
24056 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24057 PyObject *resultobj;
24058 wxTimeSpan result;
24059 char *kwnames[] = {
24060 NULL
24061 };
24062
24063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 result = wxTimeSpan::Hour();
24067
24068 wxPyEndAllowThreads(__tstate);
24069 if (PyErr_Occurred()) SWIG_fail;
24070 }
24071 {
24072 wxTimeSpan * resultptr;
24073 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24074 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24075 }
24076 return resultobj;
24077 fail:
24078 return NULL;
24079 }
24080
24081
24082 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24083 PyObject *resultobj;
24084 long arg1 ;
24085 wxTimeSpan result;
24086 PyObject * obj0 = 0 ;
24087 char *kwnames[] = {
24088 (char *) "days", NULL
24089 };
24090
24091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24092 {
24093 arg1 = (long)(SWIG_As_long(obj0));
24094 if (SWIG_arg_fail(1)) SWIG_fail;
24095 }
24096 {
24097 PyThreadState* __tstate = wxPyBeginAllowThreads();
24098 result = wxTimeSpan::Days(arg1);
24099
24100 wxPyEndAllowThreads(__tstate);
24101 if (PyErr_Occurred()) SWIG_fail;
24102 }
24103 {
24104 wxTimeSpan * resultptr;
24105 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24106 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24107 }
24108 return resultobj;
24109 fail:
24110 return NULL;
24111 }
24112
24113
24114 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24115 PyObject *resultobj;
24116 wxTimeSpan result;
24117 char *kwnames[] = {
24118 NULL
24119 };
24120
24121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24122 {
24123 PyThreadState* __tstate = wxPyBeginAllowThreads();
24124 result = wxTimeSpan::Day();
24125
24126 wxPyEndAllowThreads(__tstate);
24127 if (PyErr_Occurred()) SWIG_fail;
24128 }
24129 {
24130 wxTimeSpan * resultptr;
24131 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24132 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24133 }
24134 return resultobj;
24135 fail:
24136 return NULL;
24137 }
24138
24139
24140 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24141 PyObject *resultobj;
24142 long arg1 ;
24143 wxTimeSpan result;
24144 PyObject * obj0 = 0 ;
24145 char *kwnames[] = {
24146 (char *) "days", NULL
24147 };
24148
24149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24150 {
24151 arg1 = (long)(SWIG_As_long(obj0));
24152 if (SWIG_arg_fail(1)) SWIG_fail;
24153 }
24154 {
24155 PyThreadState* __tstate = wxPyBeginAllowThreads();
24156 result = wxTimeSpan::Weeks(arg1);
24157
24158 wxPyEndAllowThreads(__tstate);
24159 if (PyErr_Occurred()) SWIG_fail;
24160 }
24161 {
24162 wxTimeSpan * resultptr;
24163 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24164 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24165 }
24166 return resultobj;
24167 fail:
24168 return NULL;
24169 }
24170
24171
24172 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24173 PyObject *resultobj;
24174 wxTimeSpan result;
24175 char *kwnames[] = {
24176 NULL
24177 };
24178
24179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24180 {
24181 PyThreadState* __tstate = wxPyBeginAllowThreads();
24182 result = wxTimeSpan::Week();
24183
24184 wxPyEndAllowThreads(__tstate);
24185 if (PyErr_Occurred()) SWIG_fail;
24186 }
24187 {
24188 wxTimeSpan * resultptr;
24189 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24190 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24191 }
24192 return resultobj;
24193 fail:
24194 return NULL;
24195 }
24196
24197
24198 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24199 PyObject *resultobj;
24200 long arg1 = (long) 0 ;
24201 long arg2 = (long) 0 ;
24202 long arg3 = (long) 0 ;
24203 long arg4 = (long) 0 ;
24204 wxTimeSpan *result;
24205 PyObject * obj0 = 0 ;
24206 PyObject * obj1 = 0 ;
24207 PyObject * obj2 = 0 ;
24208 PyObject * obj3 = 0 ;
24209 char *kwnames[] = {
24210 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24211 };
24212
24213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24214 if (obj0) {
24215 {
24216 arg1 = (long)(SWIG_As_long(obj0));
24217 if (SWIG_arg_fail(1)) SWIG_fail;
24218 }
24219 }
24220 if (obj1) {
24221 {
24222 arg2 = (long)(SWIG_As_long(obj1));
24223 if (SWIG_arg_fail(2)) SWIG_fail;
24224 }
24225 }
24226 if (obj2) {
24227 {
24228 arg3 = (long)(SWIG_As_long(obj2));
24229 if (SWIG_arg_fail(3)) SWIG_fail;
24230 }
24231 }
24232 if (obj3) {
24233 {
24234 arg4 = (long)(SWIG_As_long(obj3));
24235 if (SWIG_arg_fail(4)) SWIG_fail;
24236 }
24237 }
24238 {
24239 PyThreadState* __tstate = wxPyBeginAllowThreads();
24240 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24241
24242 wxPyEndAllowThreads(__tstate);
24243 if (PyErr_Occurred()) SWIG_fail;
24244 }
24245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24246 return resultobj;
24247 fail:
24248 return NULL;
24249 }
24250
24251
24252 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24253 PyObject *resultobj;
24254 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24255 PyObject * obj0 = 0 ;
24256 char *kwnames[] = {
24257 (char *) "self", NULL
24258 };
24259
24260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24262 if (SWIG_arg_fail(1)) SWIG_fail;
24263 {
24264 PyThreadState* __tstate = wxPyBeginAllowThreads();
24265 delete arg1;
24266
24267 wxPyEndAllowThreads(__tstate);
24268 if (PyErr_Occurred()) SWIG_fail;
24269 }
24270 Py_INCREF(Py_None); resultobj = Py_None;
24271 return resultobj;
24272 fail:
24273 return NULL;
24274 }
24275
24276
24277 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24278 PyObject *resultobj;
24279 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24280 wxTimeSpan *arg2 = 0 ;
24281 wxTimeSpan *result;
24282 PyObject * obj0 = 0 ;
24283 PyObject * obj1 = 0 ;
24284 char *kwnames[] = {
24285 (char *) "self",(char *) "diff", NULL
24286 };
24287
24288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24290 if (SWIG_arg_fail(1)) SWIG_fail;
24291 {
24292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24293 if (SWIG_arg_fail(2)) SWIG_fail;
24294 if (arg2 == NULL) {
24295 SWIG_null_ref("wxTimeSpan");
24296 }
24297 if (SWIG_arg_fail(2)) SWIG_fail;
24298 }
24299 {
24300 PyThreadState* __tstate = wxPyBeginAllowThreads();
24301 {
24302 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24303 result = (wxTimeSpan *) &_result_ref;
24304 }
24305
24306 wxPyEndAllowThreads(__tstate);
24307 if (PyErr_Occurred()) SWIG_fail;
24308 }
24309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24310 return resultobj;
24311 fail:
24312 return NULL;
24313 }
24314
24315
24316 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24317 PyObject *resultobj;
24318 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24319 wxTimeSpan *arg2 = 0 ;
24320 wxTimeSpan *result;
24321 PyObject * obj0 = 0 ;
24322 PyObject * obj1 = 0 ;
24323 char *kwnames[] = {
24324 (char *) "self",(char *) "diff", NULL
24325 };
24326
24327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24329 if (SWIG_arg_fail(1)) SWIG_fail;
24330 {
24331 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24332 if (SWIG_arg_fail(2)) SWIG_fail;
24333 if (arg2 == NULL) {
24334 SWIG_null_ref("wxTimeSpan");
24335 }
24336 if (SWIG_arg_fail(2)) SWIG_fail;
24337 }
24338 {
24339 PyThreadState* __tstate = wxPyBeginAllowThreads();
24340 {
24341 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24342 result = (wxTimeSpan *) &_result_ref;
24343 }
24344
24345 wxPyEndAllowThreads(__tstate);
24346 if (PyErr_Occurred()) SWIG_fail;
24347 }
24348 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24349 return resultobj;
24350 fail:
24351 return NULL;
24352 }
24353
24354
24355 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24356 PyObject *resultobj;
24357 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24358 int arg2 ;
24359 wxTimeSpan *result;
24360 PyObject * obj0 = 0 ;
24361 PyObject * obj1 = 0 ;
24362 char *kwnames[] = {
24363 (char *) "self",(char *) "n", NULL
24364 };
24365
24366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24368 if (SWIG_arg_fail(1)) SWIG_fail;
24369 {
24370 arg2 = (int)(SWIG_As_int(obj1));
24371 if (SWIG_arg_fail(2)) SWIG_fail;
24372 }
24373 {
24374 PyThreadState* __tstate = wxPyBeginAllowThreads();
24375 {
24376 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24377 result = (wxTimeSpan *) &_result_ref;
24378 }
24379
24380 wxPyEndAllowThreads(__tstate);
24381 if (PyErr_Occurred()) SWIG_fail;
24382 }
24383 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24384 return resultobj;
24385 fail:
24386 return NULL;
24387 }
24388
24389
24390 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24391 PyObject *resultobj;
24392 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24393 wxTimeSpan *result;
24394 PyObject * obj0 = 0 ;
24395 char *kwnames[] = {
24396 (char *) "self", NULL
24397 };
24398
24399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24401 if (SWIG_arg_fail(1)) SWIG_fail;
24402 {
24403 PyThreadState* __tstate = wxPyBeginAllowThreads();
24404 {
24405 wxTimeSpan &_result_ref = (arg1)->Neg();
24406 result = (wxTimeSpan *) &_result_ref;
24407 }
24408
24409 wxPyEndAllowThreads(__tstate);
24410 if (PyErr_Occurred()) SWIG_fail;
24411 }
24412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24413 return resultobj;
24414 fail:
24415 return NULL;
24416 }
24417
24418
24419 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24420 PyObject *resultobj;
24421 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24422 wxTimeSpan result;
24423 PyObject * obj0 = 0 ;
24424 char *kwnames[] = {
24425 (char *) "self", NULL
24426 };
24427
24428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24430 if (SWIG_arg_fail(1)) SWIG_fail;
24431 {
24432 PyThreadState* __tstate = wxPyBeginAllowThreads();
24433 result = ((wxTimeSpan const *)arg1)->Abs();
24434
24435 wxPyEndAllowThreads(__tstate);
24436 if (PyErr_Occurred()) SWIG_fail;
24437 }
24438 {
24439 wxTimeSpan * resultptr;
24440 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24441 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24442 }
24443 return resultobj;
24444 fail:
24445 return NULL;
24446 }
24447
24448
24449 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24450 PyObject *resultobj;
24451 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24452 wxTimeSpan *arg2 = 0 ;
24453 wxTimeSpan *result;
24454 PyObject * obj0 = 0 ;
24455 PyObject * obj1 = 0 ;
24456 char *kwnames[] = {
24457 (char *) "self",(char *) "diff", NULL
24458 };
24459
24460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24462 if (SWIG_arg_fail(1)) SWIG_fail;
24463 {
24464 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24465 if (SWIG_arg_fail(2)) SWIG_fail;
24466 if (arg2 == NULL) {
24467 SWIG_null_ref("wxTimeSpan");
24468 }
24469 if (SWIG_arg_fail(2)) SWIG_fail;
24470 }
24471 {
24472 PyThreadState* __tstate = wxPyBeginAllowThreads();
24473 {
24474 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24475 result = (wxTimeSpan *) &_result_ref;
24476 }
24477
24478 wxPyEndAllowThreads(__tstate);
24479 if (PyErr_Occurred()) SWIG_fail;
24480 }
24481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24482 return resultobj;
24483 fail:
24484 return NULL;
24485 }
24486
24487
24488 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24489 PyObject *resultobj;
24490 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24491 wxTimeSpan *arg2 = 0 ;
24492 wxTimeSpan *result;
24493 PyObject * obj0 = 0 ;
24494 PyObject * obj1 = 0 ;
24495 char *kwnames[] = {
24496 (char *) "self",(char *) "diff", NULL
24497 };
24498
24499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24501 if (SWIG_arg_fail(1)) SWIG_fail;
24502 {
24503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24504 if (SWIG_arg_fail(2)) SWIG_fail;
24505 if (arg2 == NULL) {
24506 SWIG_null_ref("wxTimeSpan");
24507 }
24508 if (SWIG_arg_fail(2)) SWIG_fail;
24509 }
24510 {
24511 PyThreadState* __tstate = wxPyBeginAllowThreads();
24512 {
24513 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24514 result = (wxTimeSpan *) &_result_ref;
24515 }
24516
24517 wxPyEndAllowThreads(__tstate);
24518 if (PyErr_Occurred()) SWIG_fail;
24519 }
24520 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24521 return resultobj;
24522 fail:
24523 return NULL;
24524 }
24525
24526
24527 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24528 PyObject *resultobj;
24529 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24530 int arg2 ;
24531 wxTimeSpan *result;
24532 PyObject * obj0 = 0 ;
24533 PyObject * obj1 = 0 ;
24534 char *kwnames[] = {
24535 (char *) "self",(char *) "n", NULL
24536 };
24537
24538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24540 if (SWIG_arg_fail(1)) SWIG_fail;
24541 {
24542 arg2 = (int)(SWIG_As_int(obj1));
24543 if (SWIG_arg_fail(2)) SWIG_fail;
24544 }
24545 {
24546 PyThreadState* __tstate = wxPyBeginAllowThreads();
24547 {
24548 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24549 result = (wxTimeSpan *) &_result_ref;
24550 }
24551
24552 wxPyEndAllowThreads(__tstate);
24553 if (PyErr_Occurred()) SWIG_fail;
24554 }
24555 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24556 return resultobj;
24557 fail:
24558 return NULL;
24559 }
24560
24561
24562 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24563 PyObject *resultobj;
24564 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24565 wxTimeSpan *result;
24566 PyObject * obj0 = 0 ;
24567 char *kwnames[] = {
24568 (char *) "self", NULL
24569 };
24570
24571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24573 if (SWIG_arg_fail(1)) SWIG_fail;
24574 {
24575 PyThreadState* __tstate = wxPyBeginAllowThreads();
24576 {
24577 wxTimeSpan &_result_ref = (arg1)->operator -();
24578 result = (wxTimeSpan *) &_result_ref;
24579 }
24580
24581 wxPyEndAllowThreads(__tstate);
24582 if (PyErr_Occurred()) SWIG_fail;
24583 }
24584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24585 return resultobj;
24586 fail:
24587 return NULL;
24588 }
24589
24590
24591 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24592 PyObject *resultobj;
24593 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24594 wxTimeSpan *arg2 = 0 ;
24595 wxTimeSpan result;
24596 PyObject * obj0 = 0 ;
24597 PyObject * obj1 = 0 ;
24598 char *kwnames[] = {
24599 (char *) "self",(char *) "other", NULL
24600 };
24601
24602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24604 if (SWIG_arg_fail(1)) SWIG_fail;
24605 {
24606 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24607 if (SWIG_arg_fail(2)) SWIG_fail;
24608 if (arg2 == NULL) {
24609 SWIG_null_ref("wxTimeSpan");
24610 }
24611 if (SWIG_arg_fail(2)) SWIG_fail;
24612 }
24613 {
24614 PyThreadState* __tstate = wxPyBeginAllowThreads();
24615 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24616
24617 wxPyEndAllowThreads(__tstate);
24618 if (PyErr_Occurred()) SWIG_fail;
24619 }
24620 {
24621 wxTimeSpan * resultptr;
24622 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24623 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24624 }
24625 return resultobj;
24626 fail:
24627 return NULL;
24628 }
24629
24630
24631 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24632 PyObject *resultobj;
24633 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24634 wxTimeSpan *arg2 = 0 ;
24635 wxTimeSpan result;
24636 PyObject * obj0 = 0 ;
24637 PyObject * obj1 = 0 ;
24638 char *kwnames[] = {
24639 (char *) "self",(char *) "other", NULL
24640 };
24641
24642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24644 if (SWIG_arg_fail(1)) SWIG_fail;
24645 {
24646 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24647 if (SWIG_arg_fail(2)) SWIG_fail;
24648 if (arg2 == NULL) {
24649 SWIG_null_ref("wxTimeSpan");
24650 }
24651 if (SWIG_arg_fail(2)) SWIG_fail;
24652 }
24653 {
24654 PyThreadState* __tstate = wxPyBeginAllowThreads();
24655 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24656
24657 wxPyEndAllowThreads(__tstate);
24658 if (PyErr_Occurred()) SWIG_fail;
24659 }
24660 {
24661 wxTimeSpan * resultptr;
24662 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24663 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24664 }
24665 return resultobj;
24666 fail:
24667 return NULL;
24668 }
24669
24670
24671 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24672 PyObject *resultobj;
24673 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24674 int arg2 ;
24675 wxTimeSpan result;
24676 PyObject * obj0 = 0 ;
24677 PyObject * obj1 = 0 ;
24678 char *kwnames[] = {
24679 (char *) "self",(char *) "n", NULL
24680 };
24681
24682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24684 if (SWIG_arg_fail(1)) SWIG_fail;
24685 {
24686 arg2 = (int)(SWIG_As_int(obj1));
24687 if (SWIG_arg_fail(2)) SWIG_fail;
24688 }
24689 {
24690 PyThreadState* __tstate = wxPyBeginAllowThreads();
24691 result = wxTimeSpan___mul__(arg1,arg2);
24692
24693 wxPyEndAllowThreads(__tstate);
24694 if (PyErr_Occurred()) SWIG_fail;
24695 }
24696 {
24697 wxTimeSpan * resultptr;
24698 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24699 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24700 }
24701 return resultobj;
24702 fail:
24703 return NULL;
24704 }
24705
24706
24707 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24708 PyObject *resultobj;
24709 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24710 int arg2 ;
24711 wxTimeSpan result;
24712 PyObject * obj0 = 0 ;
24713 PyObject * obj1 = 0 ;
24714 char *kwnames[] = {
24715 (char *) "self",(char *) "n", NULL
24716 };
24717
24718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24720 if (SWIG_arg_fail(1)) SWIG_fail;
24721 {
24722 arg2 = (int)(SWIG_As_int(obj1));
24723 if (SWIG_arg_fail(2)) SWIG_fail;
24724 }
24725 {
24726 PyThreadState* __tstate = wxPyBeginAllowThreads();
24727 result = wxTimeSpan___rmul__(arg1,arg2);
24728
24729 wxPyEndAllowThreads(__tstate);
24730 if (PyErr_Occurred()) SWIG_fail;
24731 }
24732 {
24733 wxTimeSpan * resultptr;
24734 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24735 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24736 }
24737 return resultobj;
24738 fail:
24739 return NULL;
24740 }
24741
24742
24743 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24744 PyObject *resultobj;
24745 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24746 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24747 bool result;
24748 PyObject * obj0 = 0 ;
24749 PyObject * obj1 = 0 ;
24750 char *kwnames[] = {
24751 (char *) "self",(char *) "other", NULL
24752 };
24753
24754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24756 if (SWIG_arg_fail(1)) SWIG_fail;
24757 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24758 if (SWIG_arg_fail(2)) SWIG_fail;
24759 {
24760 PyThreadState* __tstate = wxPyBeginAllowThreads();
24761 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24762
24763 wxPyEndAllowThreads(__tstate);
24764 if (PyErr_Occurred()) SWIG_fail;
24765 }
24766 {
24767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24768 }
24769 return resultobj;
24770 fail:
24771 return NULL;
24772 }
24773
24774
24775 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24776 PyObject *resultobj;
24777 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24778 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24779 bool result;
24780 PyObject * obj0 = 0 ;
24781 PyObject * obj1 = 0 ;
24782 char *kwnames[] = {
24783 (char *) "self",(char *) "other", NULL
24784 };
24785
24786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24788 if (SWIG_arg_fail(1)) SWIG_fail;
24789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24790 if (SWIG_arg_fail(2)) SWIG_fail;
24791 {
24792 PyThreadState* __tstate = wxPyBeginAllowThreads();
24793 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24794
24795 wxPyEndAllowThreads(__tstate);
24796 if (PyErr_Occurred()) SWIG_fail;
24797 }
24798 {
24799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24800 }
24801 return resultobj;
24802 fail:
24803 return NULL;
24804 }
24805
24806
24807 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24808 PyObject *resultobj;
24809 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24810 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24811 bool result;
24812 PyObject * obj0 = 0 ;
24813 PyObject * obj1 = 0 ;
24814 char *kwnames[] = {
24815 (char *) "self",(char *) "other", NULL
24816 };
24817
24818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24820 if (SWIG_arg_fail(1)) SWIG_fail;
24821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24822 if (SWIG_arg_fail(2)) SWIG_fail;
24823 {
24824 PyThreadState* __tstate = wxPyBeginAllowThreads();
24825 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24826
24827 wxPyEndAllowThreads(__tstate);
24828 if (PyErr_Occurred()) SWIG_fail;
24829 }
24830 {
24831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24832 }
24833 return resultobj;
24834 fail:
24835 return NULL;
24836 }
24837
24838
24839 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24840 PyObject *resultobj;
24841 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24842 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24843 bool result;
24844 PyObject * obj0 = 0 ;
24845 PyObject * obj1 = 0 ;
24846 char *kwnames[] = {
24847 (char *) "self",(char *) "other", NULL
24848 };
24849
24850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24852 if (SWIG_arg_fail(1)) SWIG_fail;
24853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24854 if (SWIG_arg_fail(2)) SWIG_fail;
24855 {
24856 PyThreadState* __tstate = wxPyBeginAllowThreads();
24857 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24858
24859 wxPyEndAllowThreads(__tstate);
24860 if (PyErr_Occurred()) SWIG_fail;
24861 }
24862 {
24863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24864 }
24865 return resultobj;
24866 fail:
24867 return NULL;
24868 }
24869
24870
24871 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24872 PyObject *resultobj;
24873 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24874 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24875 bool result;
24876 PyObject * obj0 = 0 ;
24877 PyObject * obj1 = 0 ;
24878 char *kwnames[] = {
24879 (char *) "self",(char *) "other", NULL
24880 };
24881
24882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24884 if (SWIG_arg_fail(1)) SWIG_fail;
24885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24886 if (SWIG_arg_fail(2)) SWIG_fail;
24887 {
24888 PyThreadState* __tstate = wxPyBeginAllowThreads();
24889 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24890
24891 wxPyEndAllowThreads(__tstate);
24892 if (PyErr_Occurred()) SWIG_fail;
24893 }
24894 {
24895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24896 }
24897 return resultobj;
24898 fail:
24899 return NULL;
24900 }
24901
24902
24903 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24904 PyObject *resultobj;
24905 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24906 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24907 bool result;
24908 PyObject * obj0 = 0 ;
24909 PyObject * obj1 = 0 ;
24910 char *kwnames[] = {
24911 (char *) "self",(char *) "other", NULL
24912 };
24913
24914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24916 if (SWIG_arg_fail(1)) SWIG_fail;
24917 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24918 if (SWIG_arg_fail(2)) SWIG_fail;
24919 {
24920 PyThreadState* __tstate = wxPyBeginAllowThreads();
24921 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24922
24923 wxPyEndAllowThreads(__tstate);
24924 if (PyErr_Occurred()) SWIG_fail;
24925 }
24926 {
24927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24928 }
24929 return resultobj;
24930 fail:
24931 return NULL;
24932 }
24933
24934
24935 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24936 PyObject *resultobj;
24937 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24938 bool result;
24939 PyObject * obj0 = 0 ;
24940 char *kwnames[] = {
24941 (char *) "self", NULL
24942 };
24943
24944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24946 if (SWIG_arg_fail(1)) SWIG_fail;
24947 {
24948 PyThreadState* __tstate = wxPyBeginAllowThreads();
24949 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24950
24951 wxPyEndAllowThreads(__tstate);
24952 if (PyErr_Occurred()) SWIG_fail;
24953 }
24954 {
24955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24956 }
24957 return resultobj;
24958 fail:
24959 return NULL;
24960 }
24961
24962
24963 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24964 PyObject *resultobj;
24965 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24966 bool result;
24967 PyObject * obj0 = 0 ;
24968 char *kwnames[] = {
24969 (char *) "self", NULL
24970 };
24971
24972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24974 if (SWIG_arg_fail(1)) SWIG_fail;
24975 {
24976 PyThreadState* __tstate = wxPyBeginAllowThreads();
24977 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24978
24979 wxPyEndAllowThreads(__tstate);
24980 if (PyErr_Occurred()) SWIG_fail;
24981 }
24982 {
24983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24984 }
24985 return resultobj;
24986 fail:
24987 return NULL;
24988 }
24989
24990
24991 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24992 PyObject *resultobj;
24993 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24994 bool result;
24995 PyObject * obj0 = 0 ;
24996 char *kwnames[] = {
24997 (char *) "self", NULL
24998 };
24999
25000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
25001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25002 if (SWIG_arg_fail(1)) SWIG_fail;
25003 {
25004 PyThreadState* __tstate = wxPyBeginAllowThreads();
25005 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
25006
25007 wxPyEndAllowThreads(__tstate);
25008 if (PyErr_Occurred()) SWIG_fail;
25009 }
25010 {
25011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25012 }
25013 return resultobj;
25014 fail:
25015 return NULL;
25016 }
25017
25018
25019 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
25020 PyObject *resultobj;
25021 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25022 wxTimeSpan *arg2 = 0 ;
25023 bool result;
25024 PyObject * obj0 = 0 ;
25025 PyObject * obj1 = 0 ;
25026 char *kwnames[] = {
25027 (char *) "self",(char *) "ts", NULL
25028 };
25029
25030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
25031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25032 if (SWIG_arg_fail(1)) SWIG_fail;
25033 {
25034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25035 if (SWIG_arg_fail(2)) SWIG_fail;
25036 if (arg2 == NULL) {
25037 SWIG_null_ref("wxTimeSpan");
25038 }
25039 if (SWIG_arg_fail(2)) SWIG_fail;
25040 }
25041 {
25042 PyThreadState* __tstate = wxPyBeginAllowThreads();
25043 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
25044
25045 wxPyEndAllowThreads(__tstate);
25046 if (PyErr_Occurred()) SWIG_fail;
25047 }
25048 {
25049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25050 }
25051 return resultobj;
25052 fail:
25053 return NULL;
25054 }
25055
25056
25057 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25058 PyObject *resultobj;
25059 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25060 wxTimeSpan *arg2 = 0 ;
25061 bool result;
25062 PyObject * obj0 = 0 ;
25063 PyObject * obj1 = 0 ;
25064 char *kwnames[] = {
25065 (char *) "self",(char *) "ts", NULL
25066 };
25067
25068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25070 if (SWIG_arg_fail(1)) SWIG_fail;
25071 {
25072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25073 if (SWIG_arg_fail(2)) SWIG_fail;
25074 if (arg2 == NULL) {
25075 SWIG_null_ref("wxTimeSpan");
25076 }
25077 if (SWIG_arg_fail(2)) SWIG_fail;
25078 }
25079 {
25080 PyThreadState* __tstate = wxPyBeginAllowThreads();
25081 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25082
25083 wxPyEndAllowThreads(__tstate);
25084 if (PyErr_Occurred()) SWIG_fail;
25085 }
25086 {
25087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25088 }
25089 return resultobj;
25090 fail:
25091 return NULL;
25092 }
25093
25094
25095 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25096 PyObject *resultobj;
25097 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25098 wxTimeSpan *arg2 = 0 ;
25099 bool result;
25100 PyObject * obj0 = 0 ;
25101 PyObject * obj1 = 0 ;
25102 char *kwnames[] = {
25103 (char *) "self",(char *) "t", NULL
25104 };
25105
25106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25108 if (SWIG_arg_fail(1)) SWIG_fail;
25109 {
25110 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25111 if (SWIG_arg_fail(2)) SWIG_fail;
25112 if (arg2 == NULL) {
25113 SWIG_null_ref("wxTimeSpan");
25114 }
25115 if (SWIG_arg_fail(2)) SWIG_fail;
25116 }
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25120
25121 wxPyEndAllowThreads(__tstate);
25122 if (PyErr_Occurred()) SWIG_fail;
25123 }
25124 {
25125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25126 }
25127 return resultobj;
25128 fail:
25129 return NULL;
25130 }
25131
25132
25133 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25134 PyObject *resultobj;
25135 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25136 int result;
25137 PyObject * obj0 = 0 ;
25138 char *kwnames[] = {
25139 (char *) "self", NULL
25140 };
25141
25142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25144 if (SWIG_arg_fail(1)) SWIG_fail;
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25148
25149 wxPyEndAllowThreads(__tstate);
25150 if (PyErr_Occurred()) SWIG_fail;
25151 }
25152 {
25153 resultobj = SWIG_From_int((int)(result));
25154 }
25155 return resultobj;
25156 fail:
25157 return NULL;
25158 }
25159
25160
25161 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25162 PyObject *resultobj;
25163 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25164 int result;
25165 PyObject * obj0 = 0 ;
25166 char *kwnames[] = {
25167 (char *) "self", NULL
25168 };
25169
25170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25172 if (SWIG_arg_fail(1)) SWIG_fail;
25173 {
25174 PyThreadState* __tstate = wxPyBeginAllowThreads();
25175 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25176
25177 wxPyEndAllowThreads(__tstate);
25178 if (PyErr_Occurred()) SWIG_fail;
25179 }
25180 {
25181 resultobj = SWIG_From_int((int)(result));
25182 }
25183 return resultobj;
25184 fail:
25185 return NULL;
25186 }
25187
25188
25189 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25190 PyObject *resultobj;
25191 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25192 int result;
25193 PyObject * obj0 = 0 ;
25194 char *kwnames[] = {
25195 (char *) "self", NULL
25196 };
25197
25198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25200 if (SWIG_arg_fail(1)) SWIG_fail;
25201 {
25202 PyThreadState* __tstate = wxPyBeginAllowThreads();
25203 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25204
25205 wxPyEndAllowThreads(__tstate);
25206 if (PyErr_Occurred()) SWIG_fail;
25207 }
25208 {
25209 resultobj = SWIG_From_int((int)(result));
25210 }
25211 return resultobj;
25212 fail:
25213 return NULL;
25214 }
25215
25216
25217 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25218 PyObject *resultobj;
25219 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25220 int result;
25221 PyObject * obj0 = 0 ;
25222 char *kwnames[] = {
25223 (char *) "self", NULL
25224 };
25225
25226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25228 if (SWIG_arg_fail(1)) SWIG_fail;
25229 {
25230 PyThreadState* __tstate = wxPyBeginAllowThreads();
25231 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25232
25233 wxPyEndAllowThreads(__tstate);
25234 if (PyErr_Occurred()) SWIG_fail;
25235 }
25236 {
25237 resultobj = SWIG_From_int((int)(result));
25238 }
25239 return resultobj;
25240 fail:
25241 return NULL;
25242 }
25243
25244
25245 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25246 PyObject *resultobj;
25247 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25248 wxLongLong result;
25249 PyObject * obj0 = 0 ;
25250 char *kwnames[] = {
25251 (char *) "self", NULL
25252 };
25253
25254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25256 if (SWIG_arg_fail(1)) SWIG_fail;
25257 {
25258 PyThreadState* __tstate = wxPyBeginAllowThreads();
25259 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25260
25261 wxPyEndAllowThreads(__tstate);
25262 if (PyErr_Occurred()) SWIG_fail;
25263 }
25264 {
25265 PyObject *hi, *lo, *shifter, *shifted;
25266 hi = PyLong_FromLong( (&result)->GetHi() );
25267 lo = PyLong_FromLong( (&result)->GetLo() );
25268 shifter = PyLong_FromLong(32);
25269 shifted = PyNumber_Lshift(hi, shifter);
25270 resultobj = PyNumber_Or(shifted, lo);
25271 Py_DECREF(hi);
25272 Py_DECREF(lo);
25273 Py_DECREF(shifter);
25274 Py_DECREF(shifted);
25275 }
25276 return resultobj;
25277 fail:
25278 return NULL;
25279 }
25280
25281
25282 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25283 PyObject *resultobj;
25284 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25285 wxLongLong result;
25286 PyObject * obj0 = 0 ;
25287 char *kwnames[] = {
25288 (char *) "self", NULL
25289 };
25290
25291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25293 if (SWIG_arg_fail(1)) SWIG_fail;
25294 {
25295 PyThreadState* __tstate = wxPyBeginAllowThreads();
25296 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25297
25298 wxPyEndAllowThreads(__tstate);
25299 if (PyErr_Occurred()) SWIG_fail;
25300 }
25301 {
25302 PyObject *hi, *lo, *shifter, *shifted;
25303 hi = PyLong_FromLong( (&result)->GetHi() );
25304 lo = PyLong_FromLong( (&result)->GetLo() );
25305 shifter = PyLong_FromLong(32);
25306 shifted = PyNumber_Lshift(hi, shifter);
25307 resultobj = PyNumber_Or(shifted, lo);
25308 Py_DECREF(hi);
25309 Py_DECREF(lo);
25310 Py_DECREF(shifter);
25311 Py_DECREF(shifted);
25312 }
25313 return resultobj;
25314 fail:
25315 return NULL;
25316 }
25317
25318
25319 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25320 PyObject *resultobj;
25321 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25322 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25323 wxString *arg2 = (wxString *) &arg2_defvalue ;
25324 wxString result;
25325 bool temp2 = false ;
25326 PyObject * obj0 = 0 ;
25327 PyObject * obj1 = 0 ;
25328 char *kwnames[] = {
25329 (char *) "self",(char *) "format", NULL
25330 };
25331
25332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25334 if (SWIG_arg_fail(1)) SWIG_fail;
25335 if (obj1) {
25336 {
25337 arg2 = wxString_in_helper(obj1);
25338 if (arg2 == NULL) SWIG_fail;
25339 temp2 = true;
25340 }
25341 }
25342 {
25343 PyThreadState* __tstate = wxPyBeginAllowThreads();
25344 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25345
25346 wxPyEndAllowThreads(__tstate);
25347 if (PyErr_Occurred()) SWIG_fail;
25348 }
25349 {
25350 #if wxUSE_UNICODE
25351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25352 #else
25353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25354 #endif
25355 }
25356 {
25357 if (temp2)
25358 delete arg2;
25359 }
25360 return resultobj;
25361 fail:
25362 {
25363 if (temp2)
25364 delete arg2;
25365 }
25366 return NULL;
25367 }
25368
25369
25370 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25371 PyObject *obj;
25372 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25373 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25374 Py_INCREF(obj);
25375 return Py_BuildValue((char *)"");
25376 }
25377 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25378 PyObject *resultobj;
25379 int arg1 = (int) 0 ;
25380 int arg2 = (int) 0 ;
25381 int arg3 = (int) 0 ;
25382 int arg4 = (int) 0 ;
25383 wxDateSpan *result;
25384 PyObject * obj0 = 0 ;
25385 PyObject * obj1 = 0 ;
25386 PyObject * obj2 = 0 ;
25387 PyObject * obj3 = 0 ;
25388 char *kwnames[] = {
25389 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25390 };
25391
25392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25393 if (obj0) {
25394 {
25395 arg1 = (int)(SWIG_As_int(obj0));
25396 if (SWIG_arg_fail(1)) SWIG_fail;
25397 }
25398 }
25399 if (obj1) {
25400 {
25401 arg2 = (int)(SWIG_As_int(obj1));
25402 if (SWIG_arg_fail(2)) SWIG_fail;
25403 }
25404 }
25405 if (obj2) {
25406 {
25407 arg3 = (int)(SWIG_As_int(obj2));
25408 if (SWIG_arg_fail(3)) SWIG_fail;
25409 }
25410 }
25411 if (obj3) {
25412 {
25413 arg4 = (int)(SWIG_As_int(obj3));
25414 if (SWIG_arg_fail(4)) SWIG_fail;
25415 }
25416 }
25417 {
25418 PyThreadState* __tstate = wxPyBeginAllowThreads();
25419 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25420
25421 wxPyEndAllowThreads(__tstate);
25422 if (PyErr_Occurred()) SWIG_fail;
25423 }
25424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25425 return resultobj;
25426 fail:
25427 return NULL;
25428 }
25429
25430
25431 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25432 PyObject *resultobj;
25433 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25434 PyObject * obj0 = 0 ;
25435 char *kwnames[] = {
25436 (char *) "self", NULL
25437 };
25438
25439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25441 if (SWIG_arg_fail(1)) SWIG_fail;
25442 {
25443 PyThreadState* __tstate = wxPyBeginAllowThreads();
25444 delete arg1;
25445
25446 wxPyEndAllowThreads(__tstate);
25447 if (PyErr_Occurred()) SWIG_fail;
25448 }
25449 Py_INCREF(Py_None); resultobj = Py_None;
25450 return resultobj;
25451 fail:
25452 return NULL;
25453 }
25454
25455
25456 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25457 PyObject *resultobj;
25458 int arg1 ;
25459 wxDateSpan result;
25460 PyObject * obj0 = 0 ;
25461 char *kwnames[] = {
25462 (char *) "days", NULL
25463 };
25464
25465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25466 {
25467 arg1 = (int)(SWIG_As_int(obj0));
25468 if (SWIG_arg_fail(1)) SWIG_fail;
25469 }
25470 {
25471 PyThreadState* __tstate = wxPyBeginAllowThreads();
25472 result = wxDateSpan::Days(arg1);
25473
25474 wxPyEndAllowThreads(__tstate);
25475 if (PyErr_Occurred()) SWIG_fail;
25476 }
25477 {
25478 wxDateSpan * resultptr;
25479 resultptr = new wxDateSpan((wxDateSpan &)(result));
25480 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25481 }
25482 return resultobj;
25483 fail:
25484 return NULL;
25485 }
25486
25487
25488 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25489 PyObject *resultobj;
25490 wxDateSpan result;
25491 char *kwnames[] = {
25492 NULL
25493 };
25494
25495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25496 {
25497 PyThreadState* __tstate = wxPyBeginAllowThreads();
25498 result = wxDateSpan::Day();
25499
25500 wxPyEndAllowThreads(__tstate);
25501 if (PyErr_Occurred()) SWIG_fail;
25502 }
25503 {
25504 wxDateSpan * resultptr;
25505 resultptr = new wxDateSpan((wxDateSpan &)(result));
25506 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25507 }
25508 return resultobj;
25509 fail:
25510 return NULL;
25511 }
25512
25513
25514 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25515 PyObject *resultobj;
25516 int arg1 ;
25517 wxDateSpan result;
25518 PyObject * obj0 = 0 ;
25519 char *kwnames[] = {
25520 (char *) "weeks", NULL
25521 };
25522
25523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25524 {
25525 arg1 = (int)(SWIG_As_int(obj0));
25526 if (SWIG_arg_fail(1)) SWIG_fail;
25527 }
25528 {
25529 PyThreadState* __tstate = wxPyBeginAllowThreads();
25530 result = wxDateSpan::Weeks(arg1);
25531
25532 wxPyEndAllowThreads(__tstate);
25533 if (PyErr_Occurred()) SWIG_fail;
25534 }
25535 {
25536 wxDateSpan * resultptr;
25537 resultptr = new wxDateSpan((wxDateSpan &)(result));
25538 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25539 }
25540 return resultobj;
25541 fail:
25542 return NULL;
25543 }
25544
25545
25546 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25547 PyObject *resultobj;
25548 wxDateSpan result;
25549 char *kwnames[] = {
25550 NULL
25551 };
25552
25553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25554 {
25555 PyThreadState* __tstate = wxPyBeginAllowThreads();
25556 result = wxDateSpan::Week();
25557
25558 wxPyEndAllowThreads(__tstate);
25559 if (PyErr_Occurred()) SWIG_fail;
25560 }
25561 {
25562 wxDateSpan * resultptr;
25563 resultptr = new wxDateSpan((wxDateSpan &)(result));
25564 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25565 }
25566 return resultobj;
25567 fail:
25568 return NULL;
25569 }
25570
25571
25572 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25573 PyObject *resultobj;
25574 int arg1 ;
25575 wxDateSpan result;
25576 PyObject * obj0 = 0 ;
25577 char *kwnames[] = {
25578 (char *) "mon", NULL
25579 };
25580
25581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25582 {
25583 arg1 = (int)(SWIG_As_int(obj0));
25584 if (SWIG_arg_fail(1)) SWIG_fail;
25585 }
25586 {
25587 PyThreadState* __tstate = wxPyBeginAllowThreads();
25588 result = wxDateSpan::Months(arg1);
25589
25590 wxPyEndAllowThreads(__tstate);
25591 if (PyErr_Occurred()) SWIG_fail;
25592 }
25593 {
25594 wxDateSpan * resultptr;
25595 resultptr = new wxDateSpan((wxDateSpan &)(result));
25596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25597 }
25598 return resultobj;
25599 fail:
25600 return NULL;
25601 }
25602
25603
25604 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25605 PyObject *resultobj;
25606 wxDateSpan result;
25607 char *kwnames[] = {
25608 NULL
25609 };
25610
25611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25612 {
25613 PyThreadState* __tstate = wxPyBeginAllowThreads();
25614 result = wxDateSpan::Month();
25615
25616 wxPyEndAllowThreads(__tstate);
25617 if (PyErr_Occurred()) SWIG_fail;
25618 }
25619 {
25620 wxDateSpan * resultptr;
25621 resultptr = new wxDateSpan((wxDateSpan &)(result));
25622 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25623 }
25624 return resultobj;
25625 fail:
25626 return NULL;
25627 }
25628
25629
25630 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25631 PyObject *resultobj;
25632 int arg1 ;
25633 wxDateSpan result;
25634 PyObject * obj0 = 0 ;
25635 char *kwnames[] = {
25636 (char *) "years", NULL
25637 };
25638
25639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25640 {
25641 arg1 = (int)(SWIG_As_int(obj0));
25642 if (SWIG_arg_fail(1)) SWIG_fail;
25643 }
25644 {
25645 PyThreadState* __tstate = wxPyBeginAllowThreads();
25646 result = wxDateSpan::Years(arg1);
25647
25648 wxPyEndAllowThreads(__tstate);
25649 if (PyErr_Occurred()) SWIG_fail;
25650 }
25651 {
25652 wxDateSpan * resultptr;
25653 resultptr = new wxDateSpan((wxDateSpan &)(result));
25654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25655 }
25656 return resultobj;
25657 fail:
25658 return NULL;
25659 }
25660
25661
25662 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25663 PyObject *resultobj;
25664 wxDateSpan result;
25665 char *kwnames[] = {
25666 NULL
25667 };
25668
25669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25670 {
25671 PyThreadState* __tstate = wxPyBeginAllowThreads();
25672 result = wxDateSpan::Year();
25673
25674 wxPyEndAllowThreads(__tstate);
25675 if (PyErr_Occurred()) SWIG_fail;
25676 }
25677 {
25678 wxDateSpan * resultptr;
25679 resultptr = new wxDateSpan((wxDateSpan &)(result));
25680 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25681 }
25682 return resultobj;
25683 fail:
25684 return NULL;
25685 }
25686
25687
25688 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25689 PyObject *resultobj;
25690 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25691 int arg2 ;
25692 wxDateSpan *result;
25693 PyObject * obj0 = 0 ;
25694 PyObject * obj1 = 0 ;
25695 char *kwnames[] = {
25696 (char *) "self",(char *) "n", NULL
25697 };
25698
25699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25701 if (SWIG_arg_fail(1)) SWIG_fail;
25702 {
25703 arg2 = (int)(SWIG_As_int(obj1));
25704 if (SWIG_arg_fail(2)) SWIG_fail;
25705 }
25706 {
25707 PyThreadState* __tstate = wxPyBeginAllowThreads();
25708 {
25709 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25710 result = (wxDateSpan *) &_result_ref;
25711 }
25712
25713 wxPyEndAllowThreads(__tstate);
25714 if (PyErr_Occurred()) SWIG_fail;
25715 }
25716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25717 return resultobj;
25718 fail:
25719 return NULL;
25720 }
25721
25722
25723 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25724 PyObject *resultobj;
25725 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25726 int arg2 ;
25727 wxDateSpan *result;
25728 PyObject * obj0 = 0 ;
25729 PyObject * obj1 = 0 ;
25730 char *kwnames[] = {
25731 (char *) "self",(char *) "n", NULL
25732 };
25733
25734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25736 if (SWIG_arg_fail(1)) SWIG_fail;
25737 {
25738 arg2 = (int)(SWIG_As_int(obj1));
25739 if (SWIG_arg_fail(2)) SWIG_fail;
25740 }
25741 {
25742 PyThreadState* __tstate = wxPyBeginAllowThreads();
25743 {
25744 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25745 result = (wxDateSpan *) &_result_ref;
25746 }
25747
25748 wxPyEndAllowThreads(__tstate);
25749 if (PyErr_Occurred()) SWIG_fail;
25750 }
25751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25752 return resultobj;
25753 fail:
25754 return NULL;
25755 }
25756
25757
25758 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25759 PyObject *resultobj;
25760 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25761 int arg2 ;
25762 wxDateSpan *result;
25763 PyObject * obj0 = 0 ;
25764 PyObject * obj1 = 0 ;
25765 char *kwnames[] = {
25766 (char *) "self",(char *) "n", NULL
25767 };
25768
25769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25771 if (SWIG_arg_fail(1)) SWIG_fail;
25772 {
25773 arg2 = (int)(SWIG_As_int(obj1));
25774 if (SWIG_arg_fail(2)) SWIG_fail;
25775 }
25776 {
25777 PyThreadState* __tstate = wxPyBeginAllowThreads();
25778 {
25779 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25780 result = (wxDateSpan *) &_result_ref;
25781 }
25782
25783 wxPyEndAllowThreads(__tstate);
25784 if (PyErr_Occurred()) SWIG_fail;
25785 }
25786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25787 return resultobj;
25788 fail:
25789 return NULL;
25790 }
25791
25792
25793 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25794 PyObject *resultobj;
25795 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25796 int arg2 ;
25797 wxDateSpan *result;
25798 PyObject * obj0 = 0 ;
25799 PyObject * obj1 = 0 ;
25800 char *kwnames[] = {
25801 (char *) "self",(char *) "n", NULL
25802 };
25803
25804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25806 if (SWIG_arg_fail(1)) SWIG_fail;
25807 {
25808 arg2 = (int)(SWIG_As_int(obj1));
25809 if (SWIG_arg_fail(2)) SWIG_fail;
25810 }
25811 {
25812 PyThreadState* __tstate = wxPyBeginAllowThreads();
25813 {
25814 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25815 result = (wxDateSpan *) &_result_ref;
25816 }
25817
25818 wxPyEndAllowThreads(__tstate);
25819 if (PyErr_Occurred()) SWIG_fail;
25820 }
25821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25822 return resultobj;
25823 fail:
25824 return NULL;
25825 }
25826
25827
25828 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25829 PyObject *resultobj;
25830 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25831 int result;
25832 PyObject * obj0 = 0 ;
25833 char *kwnames[] = {
25834 (char *) "self", NULL
25835 };
25836
25837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25839 if (SWIG_arg_fail(1)) SWIG_fail;
25840 {
25841 PyThreadState* __tstate = wxPyBeginAllowThreads();
25842 result = (int)((wxDateSpan const *)arg1)->GetYears();
25843
25844 wxPyEndAllowThreads(__tstate);
25845 if (PyErr_Occurred()) SWIG_fail;
25846 }
25847 {
25848 resultobj = SWIG_From_int((int)(result));
25849 }
25850 return resultobj;
25851 fail:
25852 return NULL;
25853 }
25854
25855
25856 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25857 PyObject *resultobj;
25858 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25859 int result;
25860 PyObject * obj0 = 0 ;
25861 char *kwnames[] = {
25862 (char *) "self", NULL
25863 };
25864
25865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25867 if (SWIG_arg_fail(1)) SWIG_fail;
25868 {
25869 PyThreadState* __tstate = wxPyBeginAllowThreads();
25870 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25871
25872 wxPyEndAllowThreads(__tstate);
25873 if (PyErr_Occurred()) SWIG_fail;
25874 }
25875 {
25876 resultobj = SWIG_From_int((int)(result));
25877 }
25878 return resultobj;
25879 fail:
25880 return NULL;
25881 }
25882
25883
25884 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25885 PyObject *resultobj;
25886 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25887 int result;
25888 PyObject * obj0 = 0 ;
25889 char *kwnames[] = {
25890 (char *) "self", NULL
25891 };
25892
25893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25895 if (SWIG_arg_fail(1)) SWIG_fail;
25896 {
25897 PyThreadState* __tstate = wxPyBeginAllowThreads();
25898 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25899
25900 wxPyEndAllowThreads(__tstate);
25901 if (PyErr_Occurred()) SWIG_fail;
25902 }
25903 {
25904 resultobj = SWIG_From_int((int)(result));
25905 }
25906 return resultobj;
25907 fail:
25908 return NULL;
25909 }
25910
25911
25912 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25913 PyObject *resultobj;
25914 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25915 int result;
25916 PyObject * obj0 = 0 ;
25917 char *kwnames[] = {
25918 (char *) "self", NULL
25919 };
25920
25921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25923 if (SWIG_arg_fail(1)) SWIG_fail;
25924 {
25925 PyThreadState* __tstate = wxPyBeginAllowThreads();
25926 result = (int)((wxDateSpan const *)arg1)->GetDays();
25927
25928 wxPyEndAllowThreads(__tstate);
25929 if (PyErr_Occurred()) SWIG_fail;
25930 }
25931 {
25932 resultobj = SWIG_From_int((int)(result));
25933 }
25934 return resultobj;
25935 fail:
25936 return NULL;
25937 }
25938
25939
25940 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25941 PyObject *resultobj;
25942 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25943 int result;
25944 PyObject * obj0 = 0 ;
25945 char *kwnames[] = {
25946 (char *) "self", NULL
25947 };
25948
25949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25951 if (SWIG_arg_fail(1)) SWIG_fail;
25952 {
25953 PyThreadState* __tstate = wxPyBeginAllowThreads();
25954 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25955
25956 wxPyEndAllowThreads(__tstate);
25957 if (PyErr_Occurred()) SWIG_fail;
25958 }
25959 {
25960 resultobj = SWIG_From_int((int)(result));
25961 }
25962 return resultobj;
25963 fail:
25964 return NULL;
25965 }
25966
25967
25968 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25969 PyObject *resultobj;
25970 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25971 wxDateSpan *arg2 = 0 ;
25972 wxDateSpan *result;
25973 PyObject * obj0 = 0 ;
25974 PyObject * obj1 = 0 ;
25975 char *kwnames[] = {
25976 (char *) "self",(char *) "other", NULL
25977 };
25978
25979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25981 if (SWIG_arg_fail(1)) SWIG_fail;
25982 {
25983 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25984 if (SWIG_arg_fail(2)) SWIG_fail;
25985 if (arg2 == NULL) {
25986 SWIG_null_ref("wxDateSpan");
25987 }
25988 if (SWIG_arg_fail(2)) SWIG_fail;
25989 }
25990 {
25991 PyThreadState* __tstate = wxPyBeginAllowThreads();
25992 {
25993 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25994 result = (wxDateSpan *) &_result_ref;
25995 }
25996
25997 wxPyEndAllowThreads(__tstate);
25998 if (PyErr_Occurred()) SWIG_fail;
25999 }
26000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26001 return resultobj;
26002 fail:
26003 return NULL;
26004 }
26005
26006
26007 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
26008 PyObject *resultobj;
26009 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26010 wxDateSpan *arg2 = 0 ;
26011 wxDateSpan *result;
26012 PyObject * obj0 = 0 ;
26013 PyObject * obj1 = 0 ;
26014 char *kwnames[] = {
26015 (char *) "self",(char *) "other", NULL
26016 };
26017
26018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
26019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26020 if (SWIG_arg_fail(1)) SWIG_fail;
26021 {
26022 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26023 if (SWIG_arg_fail(2)) SWIG_fail;
26024 if (arg2 == NULL) {
26025 SWIG_null_ref("wxDateSpan");
26026 }
26027 if (SWIG_arg_fail(2)) SWIG_fail;
26028 }
26029 {
26030 PyThreadState* __tstate = wxPyBeginAllowThreads();
26031 {
26032 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26033 result = (wxDateSpan *) &_result_ref;
26034 }
26035
26036 wxPyEndAllowThreads(__tstate);
26037 if (PyErr_Occurred()) SWIG_fail;
26038 }
26039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26040 return resultobj;
26041 fail:
26042 return NULL;
26043 }
26044
26045
26046 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
26047 PyObject *resultobj;
26048 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26049 wxDateSpan *result;
26050 PyObject * obj0 = 0 ;
26051 char *kwnames[] = {
26052 (char *) "self", NULL
26053 };
26054
26055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26057 if (SWIG_arg_fail(1)) SWIG_fail;
26058 {
26059 PyThreadState* __tstate = wxPyBeginAllowThreads();
26060 {
26061 wxDateSpan &_result_ref = (arg1)->Neg();
26062 result = (wxDateSpan *) &_result_ref;
26063 }
26064
26065 wxPyEndAllowThreads(__tstate);
26066 if (PyErr_Occurred()) SWIG_fail;
26067 }
26068 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26069 return resultobj;
26070 fail:
26071 return NULL;
26072 }
26073
26074
26075 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26076 PyObject *resultobj;
26077 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26078 int arg2 ;
26079 wxDateSpan *result;
26080 PyObject * obj0 = 0 ;
26081 PyObject * obj1 = 0 ;
26082 char *kwnames[] = {
26083 (char *) "self",(char *) "factor", NULL
26084 };
26085
26086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26088 if (SWIG_arg_fail(1)) SWIG_fail;
26089 {
26090 arg2 = (int)(SWIG_As_int(obj1));
26091 if (SWIG_arg_fail(2)) SWIG_fail;
26092 }
26093 {
26094 PyThreadState* __tstate = wxPyBeginAllowThreads();
26095 {
26096 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26097 result = (wxDateSpan *) &_result_ref;
26098 }
26099
26100 wxPyEndAllowThreads(__tstate);
26101 if (PyErr_Occurred()) SWIG_fail;
26102 }
26103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26104 return resultobj;
26105 fail:
26106 return NULL;
26107 }
26108
26109
26110 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26111 PyObject *resultobj;
26112 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26113 wxDateSpan *arg2 = 0 ;
26114 wxDateSpan *result;
26115 PyObject * obj0 = 0 ;
26116 PyObject * obj1 = 0 ;
26117 char *kwnames[] = {
26118 (char *) "self",(char *) "other", NULL
26119 };
26120
26121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26123 if (SWIG_arg_fail(1)) SWIG_fail;
26124 {
26125 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26126 if (SWIG_arg_fail(2)) SWIG_fail;
26127 if (arg2 == NULL) {
26128 SWIG_null_ref("wxDateSpan");
26129 }
26130 if (SWIG_arg_fail(2)) SWIG_fail;
26131 }
26132 {
26133 PyThreadState* __tstate = wxPyBeginAllowThreads();
26134 {
26135 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26136 result = (wxDateSpan *) &_result_ref;
26137 }
26138
26139 wxPyEndAllowThreads(__tstate);
26140 if (PyErr_Occurred()) SWIG_fail;
26141 }
26142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26143 return resultobj;
26144 fail:
26145 return NULL;
26146 }
26147
26148
26149 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26150 PyObject *resultobj;
26151 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26152 wxDateSpan *arg2 = 0 ;
26153 wxDateSpan *result;
26154 PyObject * obj0 = 0 ;
26155 PyObject * obj1 = 0 ;
26156 char *kwnames[] = {
26157 (char *) "self",(char *) "other", NULL
26158 };
26159
26160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26162 if (SWIG_arg_fail(1)) SWIG_fail;
26163 {
26164 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26165 if (SWIG_arg_fail(2)) SWIG_fail;
26166 if (arg2 == NULL) {
26167 SWIG_null_ref("wxDateSpan");
26168 }
26169 if (SWIG_arg_fail(2)) SWIG_fail;
26170 }
26171 {
26172 PyThreadState* __tstate = wxPyBeginAllowThreads();
26173 {
26174 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26175 result = (wxDateSpan *) &_result_ref;
26176 }
26177
26178 wxPyEndAllowThreads(__tstate);
26179 if (PyErr_Occurred()) SWIG_fail;
26180 }
26181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26182 return resultobj;
26183 fail:
26184 return NULL;
26185 }
26186
26187
26188 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26189 PyObject *resultobj;
26190 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26191 wxDateSpan *result;
26192 PyObject * obj0 = 0 ;
26193 char *kwnames[] = {
26194 (char *) "self", NULL
26195 };
26196
26197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26199 if (SWIG_arg_fail(1)) SWIG_fail;
26200 {
26201 PyThreadState* __tstate = wxPyBeginAllowThreads();
26202 {
26203 wxDateSpan &_result_ref = (arg1)->operator -();
26204 result = (wxDateSpan *) &_result_ref;
26205 }
26206
26207 wxPyEndAllowThreads(__tstate);
26208 if (PyErr_Occurred()) SWIG_fail;
26209 }
26210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26211 return resultobj;
26212 fail:
26213 return NULL;
26214 }
26215
26216
26217 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26218 PyObject *resultobj;
26219 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26220 int arg2 ;
26221 wxDateSpan *result;
26222 PyObject * obj0 = 0 ;
26223 PyObject * obj1 = 0 ;
26224 char *kwnames[] = {
26225 (char *) "self",(char *) "factor", NULL
26226 };
26227
26228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26230 if (SWIG_arg_fail(1)) SWIG_fail;
26231 {
26232 arg2 = (int)(SWIG_As_int(obj1));
26233 if (SWIG_arg_fail(2)) SWIG_fail;
26234 }
26235 {
26236 PyThreadState* __tstate = wxPyBeginAllowThreads();
26237 {
26238 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26239 result = (wxDateSpan *) &_result_ref;
26240 }
26241
26242 wxPyEndAllowThreads(__tstate);
26243 if (PyErr_Occurred()) SWIG_fail;
26244 }
26245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26246 return resultobj;
26247 fail:
26248 return NULL;
26249 }
26250
26251
26252 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26253 PyObject *resultobj;
26254 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26255 wxDateSpan *arg2 = 0 ;
26256 wxDateSpan result;
26257 PyObject * obj0 = 0 ;
26258 PyObject * obj1 = 0 ;
26259 char *kwnames[] = {
26260 (char *) "self",(char *) "other", NULL
26261 };
26262
26263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26265 if (SWIG_arg_fail(1)) SWIG_fail;
26266 {
26267 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26268 if (SWIG_arg_fail(2)) SWIG_fail;
26269 if (arg2 == NULL) {
26270 SWIG_null_ref("wxDateSpan");
26271 }
26272 if (SWIG_arg_fail(2)) SWIG_fail;
26273 }
26274 {
26275 PyThreadState* __tstate = wxPyBeginAllowThreads();
26276 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26277
26278 wxPyEndAllowThreads(__tstate);
26279 if (PyErr_Occurred()) SWIG_fail;
26280 }
26281 {
26282 wxDateSpan * resultptr;
26283 resultptr = new wxDateSpan((wxDateSpan &)(result));
26284 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26285 }
26286 return resultobj;
26287 fail:
26288 return NULL;
26289 }
26290
26291
26292 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26293 PyObject *resultobj;
26294 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26295 wxDateSpan *arg2 = 0 ;
26296 wxDateSpan result;
26297 PyObject * obj0 = 0 ;
26298 PyObject * obj1 = 0 ;
26299 char *kwnames[] = {
26300 (char *) "self",(char *) "other", NULL
26301 };
26302
26303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26305 if (SWIG_arg_fail(1)) SWIG_fail;
26306 {
26307 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26308 if (SWIG_arg_fail(2)) SWIG_fail;
26309 if (arg2 == NULL) {
26310 SWIG_null_ref("wxDateSpan");
26311 }
26312 if (SWIG_arg_fail(2)) SWIG_fail;
26313 }
26314 {
26315 PyThreadState* __tstate = wxPyBeginAllowThreads();
26316 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26317
26318 wxPyEndAllowThreads(__tstate);
26319 if (PyErr_Occurred()) SWIG_fail;
26320 }
26321 {
26322 wxDateSpan * resultptr;
26323 resultptr = new wxDateSpan((wxDateSpan &)(result));
26324 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26325 }
26326 return resultobj;
26327 fail:
26328 return NULL;
26329 }
26330
26331
26332 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26333 PyObject *resultobj;
26334 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26335 int arg2 ;
26336 wxDateSpan result;
26337 PyObject * obj0 = 0 ;
26338 PyObject * obj1 = 0 ;
26339 char *kwnames[] = {
26340 (char *) "self",(char *) "n", NULL
26341 };
26342
26343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26345 if (SWIG_arg_fail(1)) SWIG_fail;
26346 {
26347 arg2 = (int)(SWIG_As_int(obj1));
26348 if (SWIG_arg_fail(2)) SWIG_fail;
26349 }
26350 {
26351 PyThreadState* __tstate = wxPyBeginAllowThreads();
26352 result = wxDateSpan___mul__(arg1,arg2);
26353
26354 wxPyEndAllowThreads(__tstate);
26355 if (PyErr_Occurred()) SWIG_fail;
26356 }
26357 {
26358 wxDateSpan * resultptr;
26359 resultptr = new wxDateSpan((wxDateSpan &)(result));
26360 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26361 }
26362 return resultobj;
26363 fail:
26364 return NULL;
26365 }
26366
26367
26368 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26369 PyObject *resultobj;
26370 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26371 int arg2 ;
26372 wxDateSpan result;
26373 PyObject * obj0 = 0 ;
26374 PyObject * obj1 = 0 ;
26375 char *kwnames[] = {
26376 (char *) "self",(char *) "n", NULL
26377 };
26378
26379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26381 if (SWIG_arg_fail(1)) SWIG_fail;
26382 {
26383 arg2 = (int)(SWIG_As_int(obj1));
26384 if (SWIG_arg_fail(2)) SWIG_fail;
26385 }
26386 {
26387 PyThreadState* __tstate = wxPyBeginAllowThreads();
26388 result = wxDateSpan___rmul__(arg1,arg2);
26389
26390 wxPyEndAllowThreads(__tstate);
26391 if (PyErr_Occurred()) SWIG_fail;
26392 }
26393 {
26394 wxDateSpan * resultptr;
26395 resultptr = new wxDateSpan((wxDateSpan &)(result));
26396 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26397 }
26398 return resultobj;
26399 fail:
26400 return NULL;
26401 }
26402
26403
26404 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26405 PyObject *resultobj;
26406 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26407 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26408 bool result;
26409 PyObject * obj0 = 0 ;
26410 PyObject * obj1 = 0 ;
26411 char *kwnames[] = {
26412 (char *) "self",(char *) "other", NULL
26413 };
26414
26415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26417 if (SWIG_arg_fail(1)) SWIG_fail;
26418 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26419 if (SWIG_arg_fail(2)) SWIG_fail;
26420 {
26421 PyThreadState* __tstate = wxPyBeginAllowThreads();
26422 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26423
26424 wxPyEndAllowThreads(__tstate);
26425 if (PyErr_Occurred()) SWIG_fail;
26426 }
26427 {
26428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26429 }
26430 return resultobj;
26431 fail:
26432 return NULL;
26433 }
26434
26435
26436 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26437 PyObject *resultobj;
26438 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26439 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26440 bool result;
26441 PyObject * obj0 = 0 ;
26442 PyObject * obj1 = 0 ;
26443 char *kwnames[] = {
26444 (char *) "self",(char *) "other", NULL
26445 };
26446
26447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26449 if (SWIG_arg_fail(1)) SWIG_fail;
26450 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26451 if (SWIG_arg_fail(2)) SWIG_fail;
26452 {
26453 PyThreadState* __tstate = wxPyBeginAllowThreads();
26454 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26455
26456 wxPyEndAllowThreads(__tstate);
26457 if (PyErr_Occurred()) SWIG_fail;
26458 }
26459 {
26460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26461 }
26462 return resultobj;
26463 fail:
26464 return NULL;
26465 }
26466
26467
26468 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26469 PyObject *obj;
26470 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26471 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26472 Py_INCREF(obj);
26473 return Py_BuildValue((char *)"");
26474 }
26475 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26476 PyObject *resultobj;
26477 long result;
26478 char *kwnames[] = {
26479 NULL
26480 };
26481
26482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26483 {
26484 PyThreadState* __tstate = wxPyBeginAllowThreads();
26485 result = (long)wxGetLocalTime();
26486
26487 wxPyEndAllowThreads(__tstate);
26488 if (PyErr_Occurred()) SWIG_fail;
26489 }
26490 {
26491 resultobj = SWIG_From_long((long)(result));
26492 }
26493 return resultobj;
26494 fail:
26495 return NULL;
26496 }
26497
26498
26499 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26500 PyObject *resultobj;
26501 long result;
26502 char *kwnames[] = {
26503 NULL
26504 };
26505
26506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26507 {
26508 PyThreadState* __tstate = wxPyBeginAllowThreads();
26509 result = (long)wxGetUTCTime();
26510
26511 wxPyEndAllowThreads(__tstate);
26512 if (PyErr_Occurred()) SWIG_fail;
26513 }
26514 {
26515 resultobj = SWIG_From_long((long)(result));
26516 }
26517 return resultobj;
26518 fail:
26519 return NULL;
26520 }
26521
26522
26523 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26524 PyObject *resultobj;
26525 long result;
26526 char *kwnames[] = {
26527 NULL
26528 };
26529
26530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26531 {
26532 PyThreadState* __tstate = wxPyBeginAllowThreads();
26533 result = (long)wxGetCurrentTime();
26534
26535 wxPyEndAllowThreads(__tstate);
26536 if (PyErr_Occurred()) SWIG_fail;
26537 }
26538 {
26539 resultobj = SWIG_From_long((long)(result));
26540 }
26541 return resultobj;
26542 fail:
26543 return NULL;
26544 }
26545
26546
26547 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26548 PyObject *resultobj;
26549 wxLongLong result;
26550 char *kwnames[] = {
26551 NULL
26552 };
26553
26554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26555 {
26556 PyThreadState* __tstate = wxPyBeginAllowThreads();
26557 result = wxGetLocalTimeMillis();
26558
26559 wxPyEndAllowThreads(__tstate);
26560 if (PyErr_Occurred()) SWIG_fail;
26561 }
26562 {
26563 PyObject *hi, *lo, *shifter, *shifted;
26564 hi = PyLong_FromLong( (&result)->GetHi() );
26565 lo = PyLong_FromLong( (&result)->GetLo() );
26566 shifter = PyLong_FromLong(32);
26567 shifted = PyNumber_Lshift(hi, shifter);
26568 resultobj = PyNumber_Or(shifted, lo);
26569 Py_DECREF(hi);
26570 Py_DECREF(lo);
26571 Py_DECREF(shifter);
26572 Py_DECREF(shifted);
26573 }
26574 return resultobj;
26575 fail:
26576 return NULL;
26577 }
26578
26579
26580 static int _wrap_DefaultDateTime_set(PyObject *) {
26581 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26582 return 1;
26583 }
26584
26585
26586 static PyObject *_wrap_DefaultDateTime_get(void) {
26587 PyObject *pyobj;
26588
26589 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26590 return pyobj;
26591 }
26592
26593
26594 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26595 PyObject *resultobj;
26596 wxDataFormatId arg1 ;
26597 wxDataFormat *result;
26598 PyObject * obj0 = 0 ;
26599 char *kwnames[] = {
26600 (char *) "type", NULL
26601 };
26602
26603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26604 {
26605 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26606 if (SWIG_arg_fail(1)) SWIG_fail;
26607 }
26608 {
26609 PyThreadState* __tstate = wxPyBeginAllowThreads();
26610 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26611
26612 wxPyEndAllowThreads(__tstate);
26613 if (PyErr_Occurred()) SWIG_fail;
26614 }
26615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26616 return resultobj;
26617 fail:
26618 return NULL;
26619 }
26620
26621
26622 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26623 PyObject *resultobj;
26624 wxString *arg1 = 0 ;
26625 wxDataFormat *result;
26626 bool temp1 = false ;
26627 PyObject * obj0 = 0 ;
26628 char *kwnames[] = {
26629 (char *) "format", NULL
26630 };
26631
26632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26633 {
26634 arg1 = wxString_in_helper(obj0);
26635 if (arg1 == NULL) SWIG_fail;
26636 temp1 = true;
26637 }
26638 {
26639 PyThreadState* __tstate = wxPyBeginAllowThreads();
26640 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26641
26642 wxPyEndAllowThreads(__tstate);
26643 if (PyErr_Occurred()) SWIG_fail;
26644 }
26645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26646 {
26647 if (temp1)
26648 delete arg1;
26649 }
26650 return resultobj;
26651 fail:
26652 {
26653 if (temp1)
26654 delete arg1;
26655 }
26656 return NULL;
26657 }
26658
26659
26660 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26661 PyObject *resultobj;
26662 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26663 PyObject * obj0 = 0 ;
26664 char *kwnames[] = {
26665 (char *) "self", NULL
26666 };
26667
26668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26670 if (SWIG_arg_fail(1)) SWIG_fail;
26671 {
26672 PyThreadState* __tstate = wxPyBeginAllowThreads();
26673 delete arg1;
26674
26675 wxPyEndAllowThreads(__tstate);
26676 if (PyErr_Occurred()) SWIG_fail;
26677 }
26678 Py_INCREF(Py_None); resultobj = Py_None;
26679 return resultobj;
26680 fail:
26681 return NULL;
26682 }
26683
26684
26685 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26686 PyObject *resultobj;
26687 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26688 wxDataFormatId arg2 ;
26689 bool result;
26690 PyObject * obj0 = 0 ;
26691 PyObject * obj1 = 0 ;
26692
26693 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26695 if (SWIG_arg_fail(1)) SWIG_fail;
26696 {
26697 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26698 if (SWIG_arg_fail(2)) SWIG_fail;
26699 }
26700 {
26701 PyThreadState* __tstate = wxPyBeginAllowThreads();
26702 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26703
26704 wxPyEndAllowThreads(__tstate);
26705 if (PyErr_Occurred()) SWIG_fail;
26706 }
26707 {
26708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26709 }
26710 return resultobj;
26711 fail:
26712 return NULL;
26713 }
26714
26715
26716 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26717 PyObject *resultobj;
26718 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26719 wxDataFormatId arg2 ;
26720 bool result;
26721 PyObject * obj0 = 0 ;
26722 PyObject * obj1 = 0 ;
26723
26724 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26726 if (SWIG_arg_fail(1)) SWIG_fail;
26727 {
26728 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26729 if (SWIG_arg_fail(2)) SWIG_fail;
26730 }
26731 {
26732 PyThreadState* __tstate = wxPyBeginAllowThreads();
26733 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26734
26735 wxPyEndAllowThreads(__tstate);
26736 if (PyErr_Occurred()) SWIG_fail;
26737 }
26738 {
26739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26740 }
26741 return resultobj;
26742 fail:
26743 return NULL;
26744 }
26745
26746
26747 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26748 PyObject *resultobj;
26749 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26750 wxDataFormat *arg2 = 0 ;
26751 bool result;
26752 PyObject * obj0 = 0 ;
26753 PyObject * obj1 = 0 ;
26754
26755 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26757 if (SWIG_arg_fail(1)) SWIG_fail;
26758 {
26759 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26760 if (SWIG_arg_fail(2)) SWIG_fail;
26761 if (arg2 == NULL) {
26762 SWIG_null_ref("wxDataFormat");
26763 }
26764 if (SWIG_arg_fail(2)) SWIG_fail;
26765 }
26766 {
26767 PyThreadState* __tstate = wxPyBeginAllowThreads();
26768 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26769
26770 wxPyEndAllowThreads(__tstate);
26771 if (PyErr_Occurred()) SWIG_fail;
26772 }
26773 {
26774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26775 }
26776 return resultobj;
26777 fail:
26778 return NULL;
26779 }
26780
26781
26782 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26783 int argc;
26784 PyObject *argv[3];
26785 int ii;
26786
26787 argc = PyObject_Length(args);
26788 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26789 argv[ii] = PyTuple_GetItem(args,ii);
26790 }
26791 if (argc == 2) {
26792 int _v;
26793 {
26794 void *ptr;
26795 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26796 _v = 0;
26797 PyErr_Clear();
26798 } else {
26799 _v = 1;
26800 }
26801 }
26802 if (_v) {
26803 {
26804 void *ptr = 0;
26805 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26806 _v = 0;
26807 PyErr_Clear();
26808 } else {
26809 _v = (ptr != 0);
26810 }
26811 }
26812 if (_v) {
26813 return _wrap_DataFormat___eq____SWIG_1(self,args);
26814 }
26815 }
26816 }
26817 if (argc == 2) {
26818 int _v;
26819 {
26820 void *ptr;
26821 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26822 _v = 0;
26823 PyErr_Clear();
26824 } else {
26825 _v = 1;
26826 }
26827 }
26828 if (_v) {
26829 _v = SWIG_Check_int(argv[1]);
26830 if (_v) {
26831 return _wrap_DataFormat___eq____SWIG_0(self,args);
26832 }
26833 }
26834 }
26835
26836 Py_INCREF(Py_NotImplemented);
26837 return Py_NotImplemented;
26838 }
26839
26840
26841 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26842 PyObject *resultobj;
26843 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26844 wxDataFormat *arg2 = 0 ;
26845 bool result;
26846 PyObject * obj0 = 0 ;
26847 PyObject * obj1 = 0 ;
26848
26849 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26851 if (SWIG_arg_fail(1)) SWIG_fail;
26852 {
26853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26854 if (SWIG_arg_fail(2)) SWIG_fail;
26855 if (arg2 == NULL) {
26856 SWIG_null_ref("wxDataFormat");
26857 }
26858 if (SWIG_arg_fail(2)) SWIG_fail;
26859 }
26860 {
26861 PyThreadState* __tstate = wxPyBeginAllowThreads();
26862 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26863
26864 wxPyEndAllowThreads(__tstate);
26865 if (PyErr_Occurred()) SWIG_fail;
26866 }
26867 {
26868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26869 }
26870 return resultobj;
26871 fail:
26872 return NULL;
26873 }
26874
26875
26876 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26877 int argc;
26878 PyObject *argv[3];
26879 int ii;
26880
26881 argc = PyObject_Length(args);
26882 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26883 argv[ii] = PyTuple_GetItem(args,ii);
26884 }
26885 if (argc == 2) {
26886 int _v;
26887 {
26888 void *ptr;
26889 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26890 _v = 0;
26891 PyErr_Clear();
26892 } else {
26893 _v = 1;
26894 }
26895 }
26896 if (_v) {
26897 {
26898 void *ptr = 0;
26899 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26900 _v = 0;
26901 PyErr_Clear();
26902 } else {
26903 _v = (ptr != 0);
26904 }
26905 }
26906 if (_v) {
26907 return _wrap_DataFormat___ne____SWIG_1(self,args);
26908 }
26909 }
26910 }
26911 if (argc == 2) {
26912 int _v;
26913 {
26914 void *ptr;
26915 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26916 _v = 0;
26917 PyErr_Clear();
26918 } else {
26919 _v = 1;
26920 }
26921 }
26922 if (_v) {
26923 _v = SWIG_Check_int(argv[1]);
26924 if (_v) {
26925 return _wrap_DataFormat___ne____SWIG_0(self,args);
26926 }
26927 }
26928 }
26929
26930 Py_INCREF(Py_NotImplemented);
26931 return Py_NotImplemented;
26932 }
26933
26934
26935 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26936 PyObject *resultobj;
26937 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26938 wxDataFormatId arg2 ;
26939 PyObject * obj0 = 0 ;
26940 PyObject * obj1 = 0 ;
26941 char *kwnames[] = {
26942 (char *) "self",(char *) "format", NULL
26943 };
26944
26945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26947 if (SWIG_arg_fail(1)) SWIG_fail;
26948 {
26949 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26950 if (SWIG_arg_fail(2)) SWIG_fail;
26951 }
26952 {
26953 PyThreadState* __tstate = wxPyBeginAllowThreads();
26954 (arg1)->SetType((wxDataFormatId )arg2);
26955
26956 wxPyEndAllowThreads(__tstate);
26957 if (PyErr_Occurred()) SWIG_fail;
26958 }
26959 Py_INCREF(Py_None); resultobj = Py_None;
26960 return resultobj;
26961 fail:
26962 return NULL;
26963 }
26964
26965
26966 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26967 PyObject *resultobj;
26968 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26969 wxDataFormatId result;
26970 PyObject * obj0 = 0 ;
26971 char *kwnames[] = {
26972 (char *) "self", NULL
26973 };
26974
26975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26977 if (SWIG_arg_fail(1)) SWIG_fail;
26978 {
26979 PyThreadState* __tstate = wxPyBeginAllowThreads();
26980 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26981
26982 wxPyEndAllowThreads(__tstate);
26983 if (PyErr_Occurred()) SWIG_fail;
26984 }
26985 resultobj = SWIG_From_int((result));
26986 return resultobj;
26987 fail:
26988 return NULL;
26989 }
26990
26991
26992 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26993 PyObject *resultobj;
26994 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26995 wxString result;
26996 PyObject * obj0 = 0 ;
26997 char *kwnames[] = {
26998 (char *) "self", NULL
26999 };
27000
27001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
27002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27003 if (SWIG_arg_fail(1)) SWIG_fail;
27004 {
27005 PyThreadState* __tstate = wxPyBeginAllowThreads();
27006 result = ((wxDataFormat const *)arg1)->GetId();
27007
27008 wxPyEndAllowThreads(__tstate);
27009 if (PyErr_Occurred()) SWIG_fail;
27010 }
27011 {
27012 #if wxUSE_UNICODE
27013 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27014 #else
27015 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27016 #endif
27017 }
27018 return resultobj;
27019 fail:
27020 return NULL;
27021 }
27022
27023
27024 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
27025 PyObject *resultobj;
27026 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27027 wxString *arg2 = 0 ;
27028 bool temp2 = false ;
27029 PyObject * obj0 = 0 ;
27030 PyObject * obj1 = 0 ;
27031 char *kwnames[] = {
27032 (char *) "self",(char *) "format", NULL
27033 };
27034
27035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
27036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27037 if (SWIG_arg_fail(1)) SWIG_fail;
27038 {
27039 arg2 = wxString_in_helper(obj1);
27040 if (arg2 == NULL) SWIG_fail;
27041 temp2 = true;
27042 }
27043 {
27044 PyThreadState* __tstate = wxPyBeginAllowThreads();
27045 (arg1)->SetId((wxString const &)*arg2);
27046
27047 wxPyEndAllowThreads(__tstate);
27048 if (PyErr_Occurred()) SWIG_fail;
27049 }
27050 Py_INCREF(Py_None); resultobj = Py_None;
27051 {
27052 if (temp2)
27053 delete arg2;
27054 }
27055 return resultobj;
27056 fail:
27057 {
27058 if (temp2)
27059 delete arg2;
27060 }
27061 return NULL;
27062 }
27063
27064
27065 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27066 PyObject *obj;
27067 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27068 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27069 Py_INCREF(obj);
27070 return Py_BuildValue((char *)"");
27071 }
27072 static int _wrap_FormatInvalid_set(PyObject *) {
27073 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27074 return 1;
27075 }
27076
27077
27078 static PyObject *_wrap_FormatInvalid_get(void) {
27079 PyObject *pyobj;
27080
27081 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27082 return pyobj;
27083 }
27084
27085
27086 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27087 PyObject *resultobj;
27088 wxDataObject *arg1 = (wxDataObject *) 0 ;
27089 PyObject * obj0 = 0 ;
27090 char *kwnames[] = {
27091 (char *) "self", NULL
27092 };
27093
27094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27096 if (SWIG_arg_fail(1)) SWIG_fail;
27097 {
27098 PyThreadState* __tstate = wxPyBeginAllowThreads();
27099 delete arg1;
27100
27101 wxPyEndAllowThreads(__tstate);
27102 if (PyErr_Occurred()) SWIG_fail;
27103 }
27104 Py_INCREF(Py_None); resultobj = Py_None;
27105 return resultobj;
27106 fail:
27107 return NULL;
27108 }
27109
27110
27111 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27112 PyObject *resultobj;
27113 wxDataObject *arg1 = (wxDataObject *) 0 ;
27114 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27115 SwigValueWrapper<wxDataFormat > result;
27116 PyObject * obj0 = 0 ;
27117 PyObject * obj1 = 0 ;
27118 char *kwnames[] = {
27119 (char *) "self",(char *) "dir", NULL
27120 };
27121
27122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27124 if (SWIG_arg_fail(1)) SWIG_fail;
27125 if (obj1) {
27126 {
27127 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27128 if (SWIG_arg_fail(2)) SWIG_fail;
27129 }
27130 }
27131 {
27132 PyThreadState* __tstate = wxPyBeginAllowThreads();
27133 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27134
27135 wxPyEndAllowThreads(__tstate);
27136 if (PyErr_Occurred()) SWIG_fail;
27137 }
27138 {
27139 wxDataFormat * resultptr;
27140 resultptr = new wxDataFormat((wxDataFormat &)(result));
27141 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27142 }
27143 return resultobj;
27144 fail:
27145 return NULL;
27146 }
27147
27148
27149 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27150 PyObject *resultobj;
27151 wxDataObject *arg1 = (wxDataObject *) 0 ;
27152 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27153 size_t result;
27154 PyObject * obj0 = 0 ;
27155 PyObject * obj1 = 0 ;
27156 char *kwnames[] = {
27157 (char *) "self",(char *) "dir", NULL
27158 };
27159
27160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27162 if (SWIG_arg_fail(1)) SWIG_fail;
27163 if (obj1) {
27164 {
27165 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27166 if (SWIG_arg_fail(2)) SWIG_fail;
27167 }
27168 }
27169 {
27170 PyThreadState* __tstate = wxPyBeginAllowThreads();
27171 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27172
27173 wxPyEndAllowThreads(__tstate);
27174 if (PyErr_Occurred()) SWIG_fail;
27175 }
27176 {
27177 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27178 }
27179 return resultobj;
27180 fail:
27181 return NULL;
27182 }
27183
27184
27185 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27186 PyObject *resultobj;
27187 wxDataObject *arg1 = (wxDataObject *) 0 ;
27188 wxDataFormat *arg2 = 0 ;
27189 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27190 bool result;
27191 PyObject * obj0 = 0 ;
27192 PyObject * obj1 = 0 ;
27193 PyObject * obj2 = 0 ;
27194 char *kwnames[] = {
27195 (char *) "self",(char *) "format",(char *) "dir", NULL
27196 };
27197
27198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27200 if (SWIG_arg_fail(1)) SWIG_fail;
27201 {
27202 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27203 if (SWIG_arg_fail(2)) SWIG_fail;
27204 if (arg2 == NULL) {
27205 SWIG_null_ref("wxDataFormat");
27206 }
27207 if (SWIG_arg_fail(2)) SWIG_fail;
27208 }
27209 if (obj2) {
27210 {
27211 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27212 if (SWIG_arg_fail(3)) SWIG_fail;
27213 }
27214 }
27215 {
27216 PyThreadState* __tstate = wxPyBeginAllowThreads();
27217 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27218
27219 wxPyEndAllowThreads(__tstate);
27220 if (PyErr_Occurred()) SWIG_fail;
27221 }
27222 {
27223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27224 }
27225 return resultobj;
27226 fail:
27227 return NULL;
27228 }
27229
27230
27231 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27232 PyObject *resultobj;
27233 wxDataObject *arg1 = (wxDataObject *) 0 ;
27234 wxDataFormat *arg2 = 0 ;
27235 size_t result;
27236 PyObject * obj0 = 0 ;
27237 PyObject * obj1 = 0 ;
27238 char *kwnames[] = {
27239 (char *) "self",(char *) "format", NULL
27240 };
27241
27242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27244 if (SWIG_arg_fail(1)) SWIG_fail;
27245 {
27246 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27247 if (SWIG_arg_fail(2)) SWIG_fail;
27248 if (arg2 == NULL) {
27249 SWIG_null_ref("wxDataFormat");
27250 }
27251 if (SWIG_arg_fail(2)) SWIG_fail;
27252 }
27253 {
27254 PyThreadState* __tstate = wxPyBeginAllowThreads();
27255 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27256
27257 wxPyEndAllowThreads(__tstate);
27258 if (PyErr_Occurred()) SWIG_fail;
27259 }
27260 {
27261 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27262 }
27263 return resultobj;
27264 fail:
27265 return NULL;
27266 }
27267
27268
27269 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27270 PyObject *resultobj;
27271 wxDataObject *arg1 = (wxDataObject *) 0 ;
27272 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27273 PyObject *result;
27274 PyObject * obj0 = 0 ;
27275 PyObject * obj1 = 0 ;
27276 char *kwnames[] = {
27277 (char *) "self",(char *) "dir", NULL
27278 };
27279
27280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27282 if (SWIG_arg_fail(1)) SWIG_fail;
27283 if (obj1) {
27284 {
27285 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27286 if (SWIG_arg_fail(2)) SWIG_fail;
27287 }
27288 }
27289 {
27290 PyThreadState* __tstate = wxPyBeginAllowThreads();
27291 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27292
27293 wxPyEndAllowThreads(__tstate);
27294 if (PyErr_Occurred()) SWIG_fail;
27295 }
27296 resultobj = result;
27297 return resultobj;
27298 fail:
27299 return NULL;
27300 }
27301
27302
27303 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27304 PyObject *resultobj;
27305 wxDataObject *arg1 = (wxDataObject *) 0 ;
27306 wxDataFormat *arg2 = 0 ;
27307 PyObject *result;
27308 PyObject * obj0 = 0 ;
27309 PyObject * obj1 = 0 ;
27310 char *kwnames[] = {
27311 (char *) "self",(char *) "format", NULL
27312 };
27313
27314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27316 if (SWIG_arg_fail(1)) SWIG_fail;
27317 {
27318 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27319 if (SWIG_arg_fail(2)) SWIG_fail;
27320 if (arg2 == NULL) {
27321 SWIG_null_ref("wxDataFormat");
27322 }
27323 if (SWIG_arg_fail(2)) SWIG_fail;
27324 }
27325 {
27326 PyThreadState* __tstate = wxPyBeginAllowThreads();
27327 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27328
27329 wxPyEndAllowThreads(__tstate);
27330 if (PyErr_Occurred()) SWIG_fail;
27331 }
27332 resultobj = result;
27333 return resultobj;
27334 fail:
27335 return NULL;
27336 }
27337
27338
27339 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27340 PyObject *resultobj;
27341 wxDataObject *arg1 = (wxDataObject *) 0 ;
27342 wxDataFormat *arg2 = 0 ;
27343 PyObject *arg3 = (PyObject *) 0 ;
27344 bool result;
27345 PyObject * obj0 = 0 ;
27346 PyObject * obj1 = 0 ;
27347 PyObject * obj2 = 0 ;
27348 char *kwnames[] = {
27349 (char *) "self",(char *) "format",(char *) "data", NULL
27350 };
27351
27352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27354 if (SWIG_arg_fail(1)) SWIG_fail;
27355 {
27356 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27357 if (SWIG_arg_fail(2)) SWIG_fail;
27358 if (arg2 == NULL) {
27359 SWIG_null_ref("wxDataFormat");
27360 }
27361 if (SWIG_arg_fail(2)) SWIG_fail;
27362 }
27363 arg3 = obj2;
27364 {
27365 PyThreadState* __tstate = wxPyBeginAllowThreads();
27366 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27367
27368 wxPyEndAllowThreads(__tstate);
27369 if (PyErr_Occurred()) SWIG_fail;
27370 }
27371 {
27372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27373 }
27374 return resultobj;
27375 fail:
27376 return NULL;
27377 }
27378
27379
27380 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27381 PyObject *obj;
27382 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27383 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27384 Py_INCREF(obj);
27385 return Py_BuildValue((char *)"");
27386 }
27387 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27388 PyObject *resultobj;
27389 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27390 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27391 wxDataObjectSimple *result;
27392 PyObject * obj0 = 0 ;
27393 char *kwnames[] = {
27394 (char *) "format", NULL
27395 };
27396
27397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27398 if (obj0) {
27399 {
27400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27401 if (SWIG_arg_fail(1)) SWIG_fail;
27402 if (arg1 == NULL) {
27403 SWIG_null_ref("wxDataFormat");
27404 }
27405 if (SWIG_arg_fail(1)) SWIG_fail;
27406 }
27407 }
27408 {
27409 PyThreadState* __tstate = wxPyBeginAllowThreads();
27410 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27411
27412 wxPyEndAllowThreads(__tstate);
27413 if (PyErr_Occurred()) SWIG_fail;
27414 }
27415 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27416 return resultobj;
27417 fail:
27418 return NULL;
27419 }
27420
27421
27422 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27423 PyObject *resultobj;
27424 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27425 wxDataFormat *result;
27426 PyObject * obj0 = 0 ;
27427 char *kwnames[] = {
27428 (char *) "self", NULL
27429 };
27430
27431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27433 if (SWIG_arg_fail(1)) SWIG_fail;
27434 {
27435 PyThreadState* __tstate = wxPyBeginAllowThreads();
27436 {
27437 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27438 result = (wxDataFormat *) &_result_ref;
27439 }
27440
27441 wxPyEndAllowThreads(__tstate);
27442 if (PyErr_Occurred()) SWIG_fail;
27443 }
27444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27445 return resultobj;
27446 fail:
27447 return NULL;
27448 }
27449
27450
27451 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27452 PyObject *resultobj;
27453 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27454 wxDataFormat *arg2 = 0 ;
27455 PyObject * obj0 = 0 ;
27456 PyObject * obj1 = 0 ;
27457 char *kwnames[] = {
27458 (char *) "self",(char *) "format", NULL
27459 };
27460
27461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27463 if (SWIG_arg_fail(1)) SWIG_fail;
27464 {
27465 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27466 if (SWIG_arg_fail(2)) SWIG_fail;
27467 if (arg2 == NULL) {
27468 SWIG_null_ref("wxDataFormat");
27469 }
27470 if (SWIG_arg_fail(2)) SWIG_fail;
27471 }
27472 {
27473 PyThreadState* __tstate = wxPyBeginAllowThreads();
27474 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27475
27476 wxPyEndAllowThreads(__tstate);
27477 if (PyErr_Occurred()) SWIG_fail;
27478 }
27479 Py_INCREF(Py_None); resultobj = Py_None;
27480 return resultobj;
27481 fail:
27482 return NULL;
27483 }
27484
27485
27486 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27487 PyObject *resultobj;
27488 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27489 size_t result;
27490 PyObject * obj0 = 0 ;
27491 char *kwnames[] = {
27492 (char *) "self", NULL
27493 };
27494
27495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27497 if (SWIG_arg_fail(1)) SWIG_fail;
27498 {
27499 PyThreadState* __tstate = wxPyBeginAllowThreads();
27500 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27501
27502 wxPyEndAllowThreads(__tstate);
27503 if (PyErr_Occurred()) SWIG_fail;
27504 }
27505 {
27506 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27507 }
27508 return resultobj;
27509 fail:
27510 return NULL;
27511 }
27512
27513
27514 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27515 PyObject *resultobj;
27516 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27517 PyObject *result;
27518 PyObject * obj0 = 0 ;
27519 char *kwnames[] = {
27520 (char *) "self", NULL
27521 };
27522
27523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27525 if (SWIG_arg_fail(1)) SWIG_fail;
27526 {
27527 PyThreadState* __tstate = wxPyBeginAllowThreads();
27528 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27529
27530 wxPyEndAllowThreads(__tstate);
27531 if (PyErr_Occurred()) SWIG_fail;
27532 }
27533 resultobj = result;
27534 return resultobj;
27535 fail:
27536 return NULL;
27537 }
27538
27539
27540 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27541 PyObject *resultobj;
27542 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27543 PyObject *arg2 = (PyObject *) 0 ;
27544 bool result;
27545 PyObject * obj0 = 0 ;
27546 PyObject * obj1 = 0 ;
27547 char *kwnames[] = {
27548 (char *) "self",(char *) "data", NULL
27549 };
27550
27551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27553 if (SWIG_arg_fail(1)) SWIG_fail;
27554 arg2 = obj1;
27555 {
27556 PyThreadState* __tstate = wxPyBeginAllowThreads();
27557 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27558
27559 wxPyEndAllowThreads(__tstate);
27560 if (PyErr_Occurred()) SWIG_fail;
27561 }
27562 {
27563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27564 }
27565 return resultobj;
27566 fail:
27567 return NULL;
27568 }
27569
27570
27571 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27572 PyObject *obj;
27573 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27574 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27575 Py_INCREF(obj);
27576 return Py_BuildValue((char *)"");
27577 }
27578 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27579 PyObject *resultobj;
27580 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27581 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27582 wxPyDataObjectSimple *result;
27583 PyObject * obj0 = 0 ;
27584 char *kwnames[] = {
27585 (char *) "format", NULL
27586 };
27587
27588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27589 if (obj0) {
27590 {
27591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27592 if (SWIG_arg_fail(1)) SWIG_fail;
27593 if (arg1 == NULL) {
27594 SWIG_null_ref("wxDataFormat");
27595 }
27596 if (SWIG_arg_fail(1)) SWIG_fail;
27597 }
27598 }
27599 {
27600 PyThreadState* __tstate = wxPyBeginAllowThreads();
27601 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27602
27603 wxPyEndAllowThreads(__tstate);
27604 if (PyErr_Occurred()) SWIG_fail;
27605 }
27606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27607 return resultobj;
27608 fail:
27609 return NULL;
27610 }
27611
27612
27613 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27614 PyObject *resultobj;
27615 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27616 PyObject *arg2 = (PyObject *) 0 ;
27617 PyObject *arg3 = (PyObject *) 0 ;
27618 PyObject * obj0 = 0 ;
27619 PyObject * obj1 = 0 ;
27620 PyObject * obj2 = 0 ;
27621 char *kwnames[] = {
27622 (char *) "self",(char *) "self",(char *) "_class", NULL
27623 };
27624
27625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27627 if (SWIG_arg_fail(1)) SWIG_fail;
27628 arg2 = obj1;
27629 arg3 = obj2;
27630 {
27631 PyThreadState* __tstate = wxPyBeginAllowThreads();
27632 (arg1)->_setCallbackInfo(arg2,arg3);
27633
27634 wxPyEndAllowThreads(__tstate);
27635 if (PyErr_Occurred()) SWIG_fail;
27636 }
27637 Py_INCREF(Py_None); resultobj = Py_None;
27638 return resultobj;
27639 fail:
27640 return NULL;
27641 }
27642
27643
27644 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27645 PyObject *obj;
27646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27647 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27648 Py_INCREF(obj);
27649 return Py_BuildValue((char *)"");
27650 }
27651 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27652 PyObject *resultobj;
27653 wxDataObjectComposite *result;
27654 char *kwnames[] = {
27655 NULL
27656 };
27657
27658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27659 {
27660 PyThreadState* __tstate = wxPyBeginAllowThreads();
27661 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27662
27663 wxPyEndAllowThreads(__tstate);
27664 if (PyErr_Occurred()) SWIG_fail;
27665 }
27666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27667 return resultobj;
27668 fail:
27669 return NULL;
27670 }
27671
27672
27673 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27674 PyObject *resultobj;
27675 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27676 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27677 bool arg3 = (bool) false ;
27678 PyObject * obj0 = 0 ;
27679 PyObject * obj1 = 0 ;
27680 PyObject * obj2 = 0 ;
27681 char *kwnames[] = {
27682 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27683 };
27684
27685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27687 if (SWIG_arg_fail(1)) SWIG_fail;
27688 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27689 if (SWIG_arg_fail(2)) SWIG_fail;
27690 if (obj2) {
27691 {
27692 arg3 = (bool)(SWIG_As_bool(obj2));
27693 if (SWIG_arg_fail(3)) SWIG_fail;
27694 }
27695 }
27696 {
27697 PyThreadState* __tstate = wxPyBeginAllowThreads();
27698 (arg1)->Add(arg2,arg3);
27699
27700 wxPyEndAllowThreads(__tstate);
27701 if (PyErr_Occurred()) SWIG_fail;
27702 }
27703 Py_INCREF(Py_None); resultobj = Py_None;
27704 return resultobj;
27705 fail:
27706 return NULL;
27707 }
27708
27709
27710 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27711 PyObject *obj;
27712 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27713 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27714 Py_INCREF(obj);
27715 return Py_BuildValue((char *)"");
27716 }
27717 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27718 PyObject *resultobj;
27719 wxString const &arg1_defvalue = wxPyEmptyString ;
27720 wxString *arg1 = (wxString *) &arg1_defvalue ;
27721 wxTextDataObject *result;
27722 bool temp1 = false ;
27723 PyObject * obj0 = 0 ;
27724 char *kwnames[] = {
27725 (char *) "text", NULL
27726 };
27727
27728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27729 if (obj0) {
27730 {
27731 arg1 = wxString_in_helper(obj0);
27732 if (arg1 == NULL) SWIG_fail;
27733 temp1 = true;
27734 }
27735 }
27736 {
27737 PyThreadState* __tstate = wxPyBeginAllowThreads();
27738 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27739
27740 wxPyEndAllowThreads(__tstate);
27741 if (PyErr_Occurred()) SWIG_fail;
27742 }
27743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27744 {
27745 if (temp1)
27746 delete arg1;
27747 }
27748 return resultobj;
27749 fail:
27750 {
27751 if (temp1)
27752 delete arg1;
27753 }
27754 return NULL;
27755 }
27756
27757
27758 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27759 PyObject *resultobj;
27760 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27761 size_t result;
27762 PyObject * obj0 = 0 ;
27763 char *kwnames[] = {
27764 (char *) "self", NULL
27765 };
27766
27767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27769 if (SWIG_arg_fail(1)) SWIG_fail;
27770 {
27771 PyThreadState* __tstate = wxPyBeginAllowThreads();
27772 result = (size_t)(arg1)->GetTextLength();
27773
27774 wxPyEndAllowThreads(__tstate);
27775 if (PyErr_Occurred()) SWIG_fail;
27776 }
27777 {
27778 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27779 }
27780 return resultobj;
27781 fail:
27782 return NULL;
27783 }
27784
27785
27786 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27787 PyObject *resultobj;
27788 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27789 wxString result;
27790 PyObject * obj0 = 0 ;
27791 char *kwnames[] = {
27792 (char *) "self", NULL
27793 };
27794
27795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27797 if (SWIG_arg_fail(1)) SWIG_fail;
27798 {
27799 PyThreadState* __tstate = wxPyBeginAllowThreads();
27800 result = (arg1)->GetText();
27801
27802 wxPyEndAllowThreads(__tstate);
27803 if (PyErr_Occurred()) SWIG_fail;
27804 }
27805 {
27806 #if wxUSE_UNICODE
27807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27808 #else
27809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27810 #endif
27811 }
27812 return resultobj;
27813 fail:
27814 return NULL;
27815 }
27816
27817
27818 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27819 PyObject *resultobj;
27820 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27821 wxString *arg2 = 0 ;
27822 bool temp2 = false ;
27823 PyObject * obj0 = 0 ;
27824 PyObject * obj1 = 0 ;
27825 char *kwnames[] = {
27826 (char *) "self",(char *) "text", NULL
27827 };
27828
27829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27831 if (SWIG_arg_fail(1)) SWIG_fail;
27832 {
27833 arg2 = wxString_in_helper(obj1);
27834 if (arg2 == NULL) SWIG_fail;
27835 temp2 = true;
27836 }
27837 {
27838 PyThreadState* __tstate = wxPyBeginAllowThreads();
27839 (arg1)->SetText((wxString const &)*arg2);
27840
27841 wxPyEndAllowThreads(__tstate);
27842 if (PyErr_Occurred()) SWIG_fail;
27843 }
27844 Py_INCREF(Py_None); resultobj = Py_None;
27845 {
27846 if (temp2)
27847 delete arg2;
27848 }
27849 return resultobj;
27850 fail:
27851 {
27852 if (temp2)
27853 delete arg2;
27854 }
27855 return NULL;
27856 }
27857
27858
27859 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27860 PyObject *obj;
27861 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27862 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27863 Py_INCREF(obj);
27864 return Py_BuildValue((char *)"");
27865 }
27866 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27867 PyObject *resultobj;
27868 wxString const &arg1_defvalue = wxPyEmptyString ;
27869 wxString *arg1 = (wxString *) &arg1_defvalue ;
27870 wxPyTextDataObject *result;
27871 bool temp1 = false ;
27872 PyObject * obj0 = 0 ;
27873 char *kwnames[] = {
27874 (char *) "text", NULL
27875 };
27876
27877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27878 if (obj0) {
27879 {
27880 arg1 = wxString_in_helper(obj0);
27881 if (arg1 == NULL) SWIG_fail;
27882 temp1 = true;
27883 }
27884 }
27885 {
27886 PyThreadState* __tstate = wxPyBeginAllowThreads();
27887 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27888
27889 wxPyEndAllowThreads(__tstate);
27890 if (PyErr_Occurred()) SWIG_fail;
27891 }
27892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27893 {
27894 if (temp1)
27895 delete arg1;
27896 }
27897 return resultobj;
27898 fail:
27899 {
27900 if (temp1)
27901 delete arg1;
27902 }
27903 return NULL;
27904 }
27905
27906
27907 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27908 PyObject *resultobj;
27909 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27910 PyObject *arg2 = (PyObject *) 0 ;
27911 PyObject *arg3 = (PyObject *) 0 ;
27912 PyObject * obj0 = 0 ;
27913 PyObject * obj1 = 0 ;
27914 PyObject * obj2 = 0 ;
27915 char *kwnames[] = {
27916 (char *) "self",(char *) "self",(char *) "_class", NULL
27917 };
27918
27919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27921 if (SWIG_arg_fail(1)) SWIG_fail;
27922 arg2 = obj1;
27923 arg3 = obj2;
27924 {
27925 PyThreadState* __tstate = wxPyBeginAllowThreads();
27926 (arg1)->_setCallbackInfo(arg2,arg3);
27927
27928 wxPyEndAllowThreads(__tstate);
27929 if (PyErr_Occurred()) SWIG_fail;
27930 }
27931 Py_INCREF(Py_None); resultobj = Py_None;
27932 return resultobj;
27933 fail:
27934 return NULL;
27935 }
27936
27937
27938 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27939 PyObject *obj;
27940 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27941 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27942 Py_INCREF(obj);
27943 return Py_BuildValue((char *)"");
27944 }
27945 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27946 PyObject *resultobj;
27947 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27948 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27949 wxBitmapDataObject *result;
27950 PyObject * obj0 = 0 ;
27951 char *kwnames[] = {
27952 (char *) "bitmap", NULL
27953 };
27954
27955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27956 if (obj0) {
27957 {
27958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27959 if (SWIG_arg_fail(1)) SWIG_fail;
27960 if (arg1 == NULL) {
27961 SWIG_null_ref("wxBitmap");
27962 }
27963 if (SWIG_arg_fail(1)) SWIG_fail;
27964 }
27965 }
27966 {
27967 PyThreadState* __tstate = wxPyBeginAllowThreads();
27968 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27969
27970 wxPyEndAllowThreads(__tstate);
27971 if (PyErr_Occurred()) SWIG_fail;
27972 }
27973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27974 return resultobj;
27975 fail:
27976 return NULL;
27977 }
27978
27979
27980 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27981 PyObject *resultobj;
27982 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27983 wxBitmap result;
27984 PyObject * obj0 = 0 ;
27985 char *kwnames[] = {
27986 (char *) "self", NULL
27987 };
27988
27989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27991 if (SWIG_arg_fail(1)) SWIG_fail;
27992 {
27993 PyThreadState* __tstate = wxPyBeginAllowThreads();
27994 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27995
27996 wxPyEndAllowThreads(__tstate);
27997 if (PyErr_Occurred()) SWIG_fail;
27998 }
27999 {
28000 wxBitmap * resultptr;
28001 resultptr = new wxBitmap((wxBitmap &)(result));
28002 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
28003 }
28004 return resultobj;
28005 fail:
28006 return NULL;
28007 }
28008
28009
28010 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
28011 PyObject *resultobj;
28012 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
28013 wxBitmap *arg2 = 0 ;
28014 PyObject * obj0 = 0 ;
28015 PyObject * obj1 = 0 ;
28016 char *kwnames[] = {
28017 (char *) "self",(char *) "bitmap", NULL
28018 };
28019
28020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
28021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28022 if (SWIG_arg_fail(1)) SWIG_fail;
28023 {
28024 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28025 if (SWIG_arg_fail(2)) SWIG_fail;
28026 if (arg2 == NULL) {
28027 SWIG_null_ref("wxBitmap");
28028 }
28029 if (SWIG_arg_fail(2)) SWIG_fail;
28030 }
28031 {
28032 PyThreadState* __tstate = wxPyBeginAllowThreads();
28033 (arg1)->SetBitmap((wxBitmap const &)*arg2);
28034
28035 wxPyEndAllowThreads(__tstate);
28036 if (PyErr_Occurred()) SWIG_fail;
28037 }
28038 Py_INCREF(Py_None); resultobj = Py_None;
28039 return resultobj;
28040 fail:
28041 return NULL;
28042 }
28043
28044
28045 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
28046 PyObject *obj;
28047 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28048 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
28049 Py_INCREF(obj);
28050 return Py_BuildValue((char *)"");
28051 }
28052 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28053 PyObject *resultobj;
28054 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28055 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28056 wxPyBitmapDataObject *result;
28057 PyObject * obj0 = 0 ;
28058 char *kwnames[] = {
28059 (char *) "bitmap", NULL
28060 };
28061
28062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28063 if (obj0) {
28064 {
28065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28066 if (SWIG_arg_fail(1)) SWIG_fail;
28067 if (arg1 == NULL) {
28068 SWIG_null_ref("wxBitmap");
28069 }
28070 if (SWIG_arg_fail(1)) SWIG_fail;
28071 }
28072 }
28073 {
28074 PyThreadState* __tstate = wxPyBeginAllowThreads();
28075 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28076
28077 wxPyEndAllowThreads(__tstate);
28078 if (PyErr_Occurred()) SWIG_fail;
28079 }
28080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28081 return resultobj;
28082 fail:
28083 return NULL;
28084 }
28085
28086
28087 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28088 PyObject *resultobj;
28089 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28090 PyObject *arg2 = (PyObject *) 0 ;
28091 PyObject *arg3 = (PyObject *) 0 ;
28092 PyObject * obj0 = 0 ;
28093 PyObject * obj1 = 0 ;
28094 PyObject * obj2 = 0 ;
28095 char *kwnames[] = {
28096 (char *) "self",(char *) "self",(char *) "_class", NULL
28097 };
28098
28099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28101 if (SWIG_arg_fail(1)) SWIG_fail;
28102 arg2 = obj1;
28103 arg3 = obj2;
28104 {
28105 PyThreadState* __tstate = wxPyBeginAllowThreads();
28106 (arg1)->_setCallbackInfo(arg2,arg3);
28107
28108 wxPyEndAllowThreads(__tstate);
28109 if (PyErr_Occurred()) SWIG_fail;
28110 }
28111 Py_INCREF(Py_None); resultobj = Py_None;
28112 return resultobj;
28113 fail:
28114 return NULL;
28115 }
28116
28117
28118 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28119 PyObject *obj;
28120 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28121 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28122 Py_INCREF(obj);
28123 return Py_BuildValue((char *)"");
28124 }
28125 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28126 PyObject *resultobj;
28127 wxFileDataObject *result;
28128 char *kwnames[] = {
28129 NULL
28130 };
28131
28132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28133 {
28134 PyThreadState* __tstate = wxPyBeginAllowThreads();
28135 result = (wxFileDataObject *)new wxFileDataObject();
28136
28137 wxPyEndAllowThreads(__tstate);
28138 if (PyErr_Occurred()) SWIG_fail;
28139 }
28140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28141 return resultobj;
28142 fail:
28143 return NULL;
28144 }
28145
28146
28147 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28148 PyObject *resultobj;
28149 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28150 wxArrayString *result;
28151 PyObject * obj0 = 0 ;
28152 char *kwnames[] = {
28153 (char *) "self", NULL
28154 };
28155
28156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28158 if (SWIG_arg_fail(1)) SWIG_fail;
28159 {
28160 PyThreadState* __tstate = wxPyBeginAllowThreads();
28161 {
28162 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28163 result = (wxArrayString *) &_result_ref;
28164 }
28165
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 {
28170 resultobj = wxArrayString2PyList_helper(*result);
28171 }
28172 return resultobj;
28173 fail:
28174 return NULL;
28175 }
28176
28177
28178 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28179 PyObject *resultobj;
28180 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28181 wxString *arg2 = 0 ;
28182 bool temp2 = false ;
28183 PyObject * obj0 = 0 ;
28184 PyObject * obj1 = 0 ;
28185 char *kwnames[] = {
28186 (char *) "self",(char *) "filename", NULL
28187 };
28188
28189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28191 if (SWIG_arg_fail(1)) SWIG_fail;
28192 {
28193 arg2 = wxString_in_helper(obj1);
28194 if (arg2 == NULL) SWIG_fail;
28195 temp2 = true;
28196 }
28197 {
28198 PyThreadState* __tstate = wxPyBeginAllowThreads();
28199 (arg1)->AddFile((wxString const &)*arg2);
28200
28201 wxPyEndAllowThreads(__tstate);
28202 if (PyErr_Occurred()) SWIG_fail;
28203 }
28204 Py_INCREF(Py_None); resultobj = Py_None;
28205 {
28206 if (temp2)
28207 delete arg2;
28208 }
28209 return resultobj;
28210 fail:
28211 {
28212 if (temp2)
28213 delete arg2;
28214 }
28215 return NULL;
28216 }
28217
28218
28219 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28220 PyObject *obj;
28221 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28222 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28223 Py_INCREF(obj);
28224 return Py_BuildValue((char *)"");
28225 }
28226 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28227 PyObject *resultobj;
28228 wxDataFormat *arg1 = 0 ;
28229 wxCustomDataObject *result;
28230 PyObject * obj0 = 0 ;
28231
28232 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28233 {
28234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28235 if (SWIG_arg_fail(1)) SWIG_fail;
28236 if (arg1 == NULL) {
28237 SWIG_null_ref("wxDataFormat");
28238 }
28239 if (SWIG_arg_fail(1)) SWIG_fail;
28240 }
28241 {
28242 PyThreadState* __tstate = wxPyBeginAllowThreads();
28243 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28244
28245 wxPyEndAllowThreads(__tstate);
28246 if (PyErr_Occurred()) SWIG_fail;
28247 }
28248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28249 return resultobj;
28250 fail:
28251 return NULL;
28252 }
28253
28254
28255 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28256 PyObject *resultobj;
28257 wxString *arg1 = 0 ;
28258 wxCustomDataObject *result;
28259 bool temp1 = false ;
28260 PyObject * obj0 = 0 ;
28261
28262 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28263 {
28264 arg1 = wxString_in_helper(obj0);
28265 if (arg1 == NULL) SWIG_fail;
28266 temp1 = true;
28267 }
28268 {
28269 PyThreadState* __tstate = wxPyBeginAllowThreads();
28270 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28271
28272 wxPyEndAllowThreads(__tstate);
28273 if (PyErr_Occurred()) SWIG_fail;
28274 }
28275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28276 {
28277 if (temp1)
28278 delete arg1;
28279 }
28280 return resultobj;
28281 fail:
28282 {
28283 if (temp1)
28284 delete arg1;
28285 }
28286 return NULL;
28287 }
28288
28289
28290 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28291 PyObject *resultobj;
28292 wxCustomDataObject *result;
28293
28294 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28295 {
28296 PyThreadState* __tstate = wxPyBeginAllowThreads();
28297 result = (wxCustomDataObject *)new wxCustomDataObject();
28298
28299 wxPyEndAllowThreads(__tstate);
28300 if (PyErr_Occurred()) SWIG_fail;
28301 }
28302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28303 return resultobj;
28304 fail:
28305 return NULL;
28306 }
28307
28308
28309 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28310 int argc;
28311 PyObject *argv[2];
28312 int ii;
28313
28314 argc = PyObject_Length(args);
28315 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28316 argv[ii] = PyTuple_GetItem(args,ii);
28317 }
28318 if (argc == 0) {
28319 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28320 }
28321 if (argc == 1) {
28322 int _v;
28323 {
28324 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28325 }
28326 if (_v) {
28327 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28328 }
28329 }
28330 if (argc == 1) {
28331 int _v;
28332 {
28333 void *ptr = 0;
28334 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28335 _v = 0;
28336 PyErr_Clear();
28337 } else {
28338 _v = (ptr != 0);
28339 }
28340 }
28341 if (_v) {
28342 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28343 }
28344 }
28345
28346 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28347 return NULL;
28348 }
28349
28350
28351 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28352 PyObject *resultobj;
28353 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28354 PyObject *arg2 = (PyObject *) 0 ;
28355 bool result;
28356 PyObject * obj0 = 0 ;
28357 PyObject * obj1 = 0 ;
28358 char *kwnames[] = {
28359 (char *) "self",(char *) "data", NULL
28360 };
28361
28362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28364 if (SWIG_arg_fail(1)) SWIG_fail;
28365 arg2 = obj1;
28366 {
28367 PyThreadState* __tstate = wxPyBeginAllowThreads();
28368 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28369
28370 wxPyEndAllowThreads(__tstate);
28371 if (PyErr_Occurred()) SWIG_fail;
28372 }
28373 {
28374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28375 }
28376 return resultobj;
28377 fail:
28378 return NULL;
28379 }
28380
28381
28382 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28383 PyObject *resultobj;
28384 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28385 size_t result;
28386 PyObject * obj0 = 0 ;
28387 char *kwnames[] = {
28388 (char *) "self", NULL
28389 };
28390
28391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28393 if (SWIG_arg_fail(1)) SWIG_fail;
28394 {
28395 PyThreadState* __tstate = wxPyBeginAllowThreads();
28396 result = (size_t)(arg1)->GetSize();
28397
28398 wxPyEndAllowThreads(__tstate);
28399 if (PyErr_Occurred()) SWIG_fail;
28400 }
28401 {
28402 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28403 }
28404 return resultobj;
28405 fail:
28406 return NULL;
28407 }
28408
28409
28410 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28411 PyObject *resultobj;
28412 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28413 PyObject *result;
28414 PyObject * obj0 = 0 ;
28415 char *kwnames[] = {
28416 (char *) "self", NULL
28417 };
28418
28419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28421 if (SWIG_arg_fail(1)) SWIG_fail;
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28425
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 resultobj = result;
28430 return resultobj;
28431 fail:
28432 return NULL;
28433 }
28434
28435
28436 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28437 PyObject *obj;
28438 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28439 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28440 Py_INCREF(obj);
28441 return Py_BuildValue((char *)"");
28442 }
28443 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28444 PyObject *resultobj;
28445 wxURLDataObject *result;
28446 char *kwnames[] = {
28447 NULL
28448 };
28449
28450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28451 {
28452 PyThreadState* __tstate = wxPyBeginAllowThreads();
28453 result = (wxURLDataObject *)new wxURLDataObject();
28454
28455 wxPyEndAllowThreads(__tstate);
28456 if (PyErr_Occurred()) SWIG_fail;
28457 }
28458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28459 return resultobj;
28460 fail:
28461 return NULL;
28462 }
28463
28464
28465 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28466 PyObject *resultobj;
28467 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28468 wxString result;
28469 PyObject * obj0 = 0 ;
28470 char *kwnames[] = {
28471 (char *) "self", NULL
28472 };
28473
28474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28476 if (SWIG_arg_fail(1)) SWIG_fail;
28477 {
28478 PyThreadState* __tstate = wxPyBeginAllowThreads();
28479 result = (arg1)->GetURL();
28480
28481 wxPyEndAllowThreads(__tstate);
28482 if (PyErr_Occurred()) SWIG_fail;
28483 }
28484 {
28485 #if wxUSE_UNICODE
28486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28487 #else
28488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28489 #endif
28490 }
28491 return resultobj;
28492 fail:
28493 return NULL;
28494 }
28495
28496
28497 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28498 PyObject *resultobj;
28499 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28500 wxString *arg2 = 0 ;
28501 bool temp2 = false ;
28502 PyObject * obj0 = 0 ;
28503 PyObject * obj1 = 0 ;
28504 char *kwnames[] = {
28505 (char *) "self",(char *) "url", NULL
28506 };
28507
28508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28510 if (SWIG_arg_fail(1)) SWIG_fail;
28511 {
28512 arg2 = wxString_in_helper(obj1);
28513 if (arg2 == NULL) SWIG_fail;
28514 temp2 = true;
28515 }
28516 {
28517 PyThreadState* __tstate = wxPyBeginAllowThreads();
28518 (arg1)->SetURL((wxString const &)*arg2);
28519
28520 wxPyEndAllowThreads(__tstate);
28521 if (PyErr_Occurred()) SWIG_fail;
28522 }
28523 Py_INCREF(Py_None); resultobj = Py_None;
28524 {
28525 if (temp2)
28526 delete arg2;
28527 }
28528 return resultobj;
28529 fail:
28530 {
28531 if (temp2)
28532 delete arg2;
28533 }
28534 return NULL;
28535 }
28536
28537
28538 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28539 PyObject *obj;
28540 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28541 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28542 Py_INCREF(obj);
28543 return Py_BuildValue((char *)"");
28544 }
28545 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28546 PyObject *resultobj;
28547 wxMetafileDataObject *result;
28548 char *kwnames[] = {
28549 NULL
28550 };
28551
28552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28553 {
28554 PyThreadState* __tstate = wxPyBeginAllowThreads();
28555 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28556
28557 wxPyEndAllowThreads(__tstate);
28558 if (PyErr_Occurred()) SWIG_fail;
28559 }
28560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28561 return resultobj;
28562 fail:
28563 return NULL;
28564 }
28565
28566
28567 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28568 PyObject *resultobj;
28569 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28570 wxMetafile *arg2 = 0 ;
28571 PyObject * obj0 = 0 ;
28572 PyObject * obj1 = 0 ;
28573 char *kwnames[] = {
28574 (char *) "self",(char *) "metafile", NULL
28575 };
28576
28577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28579 if (SWIG_arg_fail(1)) SWIG_fail;
28580 {
28581 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28582 if (SWIG_arg_fail(2)) SWIG_fail;
28583 if (arg2 == NULL) {
28584 SWIG_null_ref("wxMetafile");
28585 }
28586 if (SWIG_arg_fail(2)) SWIG_fail;
28587 }
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28591
28592 wxPyEndAllowThreads(__tstate);
28593 if (PyErr_Occurred()) SWIG_fail;
28594 }
28595 Py_INCREF(Py_None); resultobj = Py_None;
28596 return resultobj;
28597 fail:
28598 return NULL;
28599 }
28600
28601
28602 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28603 PyObject *resultobj;
28604 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28605 wxMetafile result;
28606 PyObject * obj0 = 0 ;
28607 char *kwnames[] = {
28608 (char *) "self", NULL
28609 };
28610
28611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28613 if (SWIG_arg_fail(1)) SWIG_fail;
28614 {
28615 PyThreadState* __tstate = wxPyBeginAllowThreads();
28616 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28617
28618 wxPyEndAllowThreads(__tstate);
28619 if (PyErr_Occurred()) SWIG_fail;
28620 }
28621 {
28622 wxMetafile * resultptr;
28623 resultptr = new wxMetafile((wxMetafile &)(result));
28624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28625 }
28626 return resultobj;
28627 fail:
28628 return NULL;
28629 }
28630
28631
28632 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28633 PyObject *obj;
28634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28635 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28636 Py_INCREF(obj);
28637 return Py_BuildValue((char *)"");
28638 }
28639 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28640 PyObject *resultobj;
28641 wxDragResult arg1 ;
28642 bool result;
28643 PyObject * obj0 = 0 ;
28644 char *kwnames[] = {
28645 (char *) "res", NULL
28646 };
28647
28648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28649 {
28650 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28651 if (SWIG_arg_fail(1)) SWIG_fail;
28652 }
28653 {
28654 PyThreadState* __tstate = wxPyBeginAllowThreads();
28655 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28656
28657 wxPyEndAllowThreads(__tstate);
28658 if (PyErr_Occurred()) SWIG_fail;
28659 }
28660 {
28661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28662 }
28663 return resultobj;
28664 fail:
28665 return NULL;
28666 }
28667
28668
28669 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28670 PyObject *resultobj;
28671 wxWindow *arg1 = (wxWindow *) 0 ;
28672 wxCursor const &arg2_defvalue = wxNullCursor ;
28673 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28674 wxCursor const &arg3_defvalue = wxNullCursor ;
28675 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28676 wxCursor const &arg4_defvalue = wxNullCursor ;
28677 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28678 wxPyDropSource *result;
28679 PyObject * obj0 = 0 ;
28680 PyObject * obj1 = 0 ;
28681 PyObject * obj2 = 0 ;
28682 PyObject * obj3 = 0 ;
28683 char *kwnames[] = {
28684 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28685 };
28686
28687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28689 if (SWIG_arg_fail(1)) SWIG_fail;
28690 if (obj1) {
28691 {
28692 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28693 if (SWIG_arg_fail(2)) SWIG_fail;
28694 if (arg2 == NULL) {
28695 SWIG_null_ref("wxCursor");
28696 }
28697 if (SWIG_arg_fail(2)) SWIG_fail;
28698 }
28699 }
28700 if (obj2) {
28701 {
28702 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28703 if (SWIG_arg_fail(3)) SWIG_fail;
28704 if (arg3 == NULL) {
28705 SWIG_null_ref("wxCursor");
28706 }
28707 if (SWIG_arg_fail(3)) SWIG_fail;
28708 }
28709 }
28710 if (obj3) {
28711 {
28712 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28713 if (SWIG_arg_fail(4)) SWIG_fail;
28714 if (arg4 == NULL) {
28715 SWIG_null_ref("wxCursor");
28716 }
28717 if (SWIG_arg_fail(4)) SWIG_fail;
28718 }
28719 }
28720 {
28721 PyThreadState* __tstate = wxPyBeginAllowThreads();
28722 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28723
28724 wxPyEndAllowThreads(__tstate);
28725 if (PyErr_Occurred()) SWIG_fail;
28726 }
28727 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28728 return resultobj;
28729 fail:
28730 return NULL;
28731 }
28732
28733
28734 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28735 PyObject *resultobj;
28736 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28737 PyObject *arg2 = (PyObject *) 0 ;
28738 PyObject *arg3 = (PyObject *) 0 ;
28739 int arg4 ;
28740 PyObject * obj0 = 0 ;
28741 PyObject * obj1 = 0 ;
28742 PyObject * obj2 = 0 ;
28743 PyObject * obj3 = 0 ;
28744 char *kwnames[] = {
28745 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28746 };
28747
28748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28750 if (SWIG_arg_fail(1)) SWIG_fail;
28751 arg2 = obj1;
28752 arg3 = obj2;
28753 {
28754 arg4 = (int)(SWIG_As_int(obj3));
28755 if (SWIG_arg_fail(4)) SWIG_fail;
28756 }
28757 {
28758 PyThreadState* __tstate = wxPyBeginAllowThreads();
28759 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28760
28761 wxPyEndAllowThreads(__tstate);
28762 if (PyErr_Occurred()) SWIG_fail;
28763 }
28764 Py_INCREF(Py_None); resultobj = Py_None;
28765 return resultobj;
28766 fail:
28767 return NULL;
28768 }
28769
28770
28771 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28772 PyObject *resultobj;
28773 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28774 PyObject * obj0 = 0 ;
28775 char *kwnames[] = {
28776 (char *) "self", NULL
28777 };
28778
28779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28781 if (SWIG_arg_fail(1)) SWIG_fail;
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 delete arg1;
28785
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 Py_INCREF(Py_None); resultobj = Py_None;
28790 return resultobj;
28791 fail:
28792 return NULL;
28793 }
28794
28795
28796 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28797 PyObject *resultobj;
28798 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28799 wxDataObject *arg2 = 0 ;
28800 PyObject * obj0 = 0 ;
28801 PyObject * obj1 = 0 ;
28802 char *kwnames[] = {
28803 (char *) "self",(char *) "data", NULL
28804 };
28805
28806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28808 if (SWIG_arg_fail(1)) SWIG_fail;
28809 {
28810 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28811 if (SWIG_arg_fail(2)) SWIG_fail;
28812 if (arg2 == NULL) {
28813 SWIG_null_ref("wxDataObject");
28814 }
28815 if (SWIG_arg_fail(2)) SWIG_fail;
28816 }
28817 {
28818 PyThreadState* __tstate = wxPyBeginAllowThreads();
28819 (arg1)->SetData(*arg2);
28820
28821 wxPyEndAllowThreads(__tstate);
28822 if (PyErr_Occurred()) SWIG_fail;
28823 }
28824 Py_INCREF(Py_None); resultobj = Py_None;
28825 return resultobj;
28826 fail:
28827 return NULL;
28828 }
28829
28830
28831 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28832 PyObject *resultobj;
28833 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28834 wxDataObject *result;
28835 PyObject * obj0 = 0 ;
28836 char *kwnames[] = {
28837 (char *) "self", NULL
28838 };
28839
28840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28842 if (SWIG_arg_fail(1)) SWIG_fail;
28843 {
28844 PyThreadState* __tstate = wxPyBeginAllowThreads();
28845 result = (wxDataObject *)(arg1)->GetDataObject();
28846
28847 wxPyEndAllowThreads(__tstate);
28848 if (PyErr_Occurred()) SWIG_fail;
28849 }
28850 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28851 return resultobj;
28852 fail:
28853 return NULL;
28854 }
28855
28856
28857 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28858 PyObject *resultobj;
28859 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28860 wxDragResult arg2 ;
28861 wxCursor *arg3 = 0 ;
28862 PyObject * obj0 = 0 ;
28863 PyObject * obj1 = 0 ;
28864 PyObject * obj2 = 0 ;
28865 char *kwnames[] = {
28866 (char *) "self",(char *) "res",(char *) "cursor", NULL
28867 };
28868
28869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28871 if (SWIG_arg_fail(1)) SWIG_fail;
28872 {
28873 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28874 if (SWIG_arg_fail(2)) SWIG_fail;
28875 }
28876 {
28877 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28878 if (SWIG_arg_fail(3)) SWIG_fail;
28879 if (arg3 == NULL) {
28880 SWIG_null_ref("wxCursor");
28881 }
28882 if (SWIG_arg_fail(3)) SWIG_fail;
28883 }
28884 {
28885 PyThreadState* __tstate = wxPyBeginAllowThreads();
28886 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28887
28888 wxPyEndAllowThreads(__tstate);
28889 if (PyErr_Occurred()) SWIG_fail;
28890 }
28891 Py_INCREF(Py_None); resultobj = Py_None;
28892 return resultobj;
28893 fail:
28894 return NULL;
28895 }
28896
28897
28898 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28899 PyObject *resultobj;
28900 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28901 int arg2 = (int) wxDrag_CopyOnly ;
28902 wxDragResult result;
28903 PyObject * obj0 = 0 ;
28904 PyObject * obj1 = 0 ;
28905 char *kwnames[] = {
28906 (char *) "self",(char *) "flags", NULL
28907 };
28908
28909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28911 if (SWIG_arg_fail(1)) SWIG_fail;
28912 if (obj1) {
28913 {
28914 arg2 = (int)(SWIG_As_int(obj1));
28915 if (SWIG_arg_fail(2)) SWIG_fail;
28916 }
28917 }
28918 {
28919 PyThreadState* __tstate = wxPyBeginAllowThreads();
28920 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28921
28922 wxPyEndAllowThreads(__tstate);
28923 if (PyErr_Occurred()) SWIG_fail;
28924 }
28925 resultobj = SWIG_From_int((result));
28926 return resultobj;
28927 fail:
28928 return NULL;
28929 }
28930
28931
28932 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28933 PyObject *resultobj;
28934 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28935 wxDragResult arg2 ;
28936 bool result;
28937 PyObject * obj0 = 0 ;
28938 PyObject * obj1 = 0 ;
28939 char *kwnames[] = {
28940 (char *) "self",(char *) "effect", NULL
28941 };
28942
28943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28945 if (SWIG_arg_fail(1)) SWIG_fail;
28946 {
28947 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28948 if (SWIG_arg_fail(2)) SWIG_fail;
28949 }
28950 {
28951 PyThreadState* __tstate = wxPyBeginAllowThreads();
28952 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28953
28954 wxPyEndAllowThreads(__tstate);
28955 if (PyErr_Occurred()) SWIG_fail;
28956 }
28957 {
28958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28959 }
28960 return resultobj;
28961 fail:
28962 return NULL;
28963 }
28964
28965
28966 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28967 PyObject *obj;
28968 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28969 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28970 Py_INCREF(obj);
28971 return Py_BuildValue((char *)"");
28972 }
28973 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28974 PyObject *resultobj;
28975 wxDataObject *arg1 = (wxDataObject *) NULL ;
28976 wxPyDropTarget *result;
28977 PyObject * obj0 = 0 ;
28978 char *kwnames[] = {
28979 (char *) "dataObject", NULL
28980 };
28981
28982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28983 if (obj0) {
28984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28985 if (SWIG_arg_fail(1)) SWIG_fail;
28986 }
28987 {
28988 PyThreadState* __tstate = wxPyBeginAllowThreads();
28989 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28990
28991 wxPyEndAllowThreads(__tstate);
28992 if (PyErr_Occurred()) SWIG_fail;
28993 }
28994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28995 return resultobj;
28996 fail:
28997 return NULL;
28998 }
28999
29000
29001 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29002 PyObject *resultobj;
29003 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29004 PyObject *arg2 = (PyObject *) 0 ;
29005 PyObject *arg3 = (PyObject *) 0 ;
29006 PyObject * obj0 = 0 ;
29007 PyObject * obj1 = 0 ;
29008 PyObject * obj2 = 0 ;
29009 char *kwnames[] = {
29010 (char *) "self",(char *) "self",(char *) "_class", NULL
29011 };
29012
29013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29015 if (SWIG_arg_fail(1)) SWIG_fail;
29016 arg2 = obj1;
29017 arg3 = obj2;
29018 {
29019 PyThreadState* __tstate = wxPyBeginAllowThreads();
29020 (arg1)->_setCallbackInfo(arg2,arg3);
29021
29022 wxPyEndAllowThreads(__tstate);
29023 if (PyErr_Occurred()) SWIG_fail;
29024 }
29025 Py_INCREF(Py_None); resultobj = Py_None;
29026 return resultobj;
29027 fail:
29028 return NULL;
29029 }
29030
29031
29032 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29033 PyObject *resultobj;
29034 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29035 PyObject * obj0 = 0 ;
29036 char *kwnames[] = {
29037 (char *) "self", NULL
29038 };
29039
29040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
29041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29042 if (SWIG_arg_fail(1)) SWIG_fail;
29043 {
29044 PyThreadState* __tstate = wxPyBeginAllowThreads();
29045 delete arg1;
29046
29047 wxPyEndAllowThreads(__tstate);
29048 if (PyErr_Occurred()) SWIG_fail;
29049 }
29050 Py_INCREF(Py_None); resultobj = Py_None;
29051 return resultobj;
29052 fail:
29053 return NULL;
29054 }
29055
29056
29057 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29058 PyObject *resultobj;
29059 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29060 wxDataObject *result;
29061 PyObject * obj0 = 0 ;
29062 char *kwnames[] = {
29063 (char *) "self", NULL
29064 };
29065
29066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
29067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29068 if (SWIG_arg_fail(1)) SWIG_fail;
29069 {
29070 PyThreadState* __tstate = wxPyBeginAllowThreads();
29071 result = (wxDataObject *)(arg1)->GetDataObject();
29072
29073 wxPyEndAllowThreads(__tstate);
29074 if (PyErr_Occurred()) SWIG_fail;
29075 }
29076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29077 return resultobj;
29078 fail:
29079 return NULL;
29080 }
29081
29082
29083 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29084 PyObject *resultobj;
29085 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29086 wxDataObject *arg2 = (wxDataObject *) 0 ;
29087 PyObject * obj0 = 0 ;
29088 PyObject * obj1 = 0 ;
29089 char *kwnames[] = {
29090 (char *) "self",(char *) "dataObject", NULL
29091 };
29092
29093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29095 if (SWIG_arg_fail(1)) SWIG_fail;
29096 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29097 if (SWIG_arg_fail(2)) SWIG_fail;
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 (arg1)->SetDataObject(arg2);
29101
29102 wxPyEndAllowThreads(__tstate);
29103 if (PyErr_Occurred()) SWIG_fail;
29104 }
29105 Py_INCREF(Py_None); resultobj = Py_None;
29106 return resultobj;
29107 fail:
29108 return NULL;
29109 }
29110
29111
29112 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29113 PyObject *resultobj;
29114 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29115 int arg2 ;
29116 int arg3 ;
29117 wxDragResult arg4 ;
29118 wxDragResult result;
29119 PyObject * obj0 = 0 ;
29120 PyObject * obj1 = 0 ;
29121 PyObject * obj2 = 0 ;
29122 PyObject * obj3 = 0 ;
29123 char *kwnames[] = {
29124 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29125 };
29126
29127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29129 if (SWIG_arg_fail(1)) SWIG_fail;
29130 {
29131 arg2 = (int)(SWIG_As_int(obj1));
29132 if (SWIG_arg_fail(2)) SWIG_fail;
29133 }
29134 {
29135 arg3 = (int)(SWIG_As_int(obj2));
29136 if (SWIG_arg_fail(3)) SWIG_fail;
29137 }
29138 {
29139 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29140 if (SWIG_arg_fail(4)) SWIG_fail;
29141 }
29142 {
29143 PyThreadState* __tstate = wxPyBeginAllowThreads();
29144 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29145
29146 wxPyEndAllowThreads(__tstate);
29147 if (PyErr_Occurred()) SWIG_fail;
29148 }
29149 resultobj = SWIG_From_int((result));
29150 return resultobj;
29151 fail:
29152 return NULL;
29153 }
29154
29155
29156 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29157 PyObject *resultobj;
29158 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29159 int arg2 ;
29160 int arg3 ;
29161 wxDragResult arg4 ;
29162 wxDragResult result;
29163 PyObject * obj0 = 0 ;
29164 PyObject * obj1 = 0 ;
29165 PyObject * obj2 = 0 ;
29166 PyObject * obj3 = 0 ;
29167 char *kwnames[] = {
29168 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29169 };
29170
29171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29173 if (SWIG_arg_fail(1)) SWIG_fail;
29174 {
29175 arg2 = (int)(SWIG_As_int(obj1));
29176 if (SWIG_arg_fail(2)) SWIG_fail;
29177 }
29178 {
29179 arg3 = (int)(SWIG_As_int(obj2));
29180 if (SWIG_arg_fail(3)) SWIG_fail;
29181 }
29182 {
29183 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29184 if (SWIG_arg_fail(4)) SWIG_fail;
29185 }
29186 {
29187 PyThreadState* __tstate = wxPyBeginAllowThreads();
29188 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29189
29190 wxPyEndAllowThreads(__tstate);
29191 if (PyErr_Occurred()) SWIG_fail;
29192 }
29193 resultobj = SWIG_From_int((result));
29194 return resultobj;
29195 fail:
29196 return NULL;
29197 }
29198
29199
29200 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29201 PyObject *resultobj;
29202 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29203 PyObject * obj0 = 0 ;
29204 char *kwnames[] = {
29205 (char *) "self", NULL
29206 };
29207
29208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29210 if (SWIG_arg_fail(1)) SWIG_fail;
29211 {
29212 PyThreadState* __tstate = wxPyBeginAllowThreads();
29213 (arg1)->base_OnLeave();
29214
29215 wxPyEndAllowThreads(__tstate);
29216 if (PyErr_Occurred()) SWIG_fail;
29217 }
29218 Py_INCREF(Py_None); resultobj = Py_None;
29219 return resultobj;
29220 fail:
29221 return NULL;
29222 }
29223
29224
29225 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29226 PyObject *resultobj;
29227 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29228 int arg2 ;
29229 int arg3 ;
29230 bool result;
29231 PyObject * obj0 = 0 ;
29232 PyObject * obj1 = 0 ;
29233 PyObject * obj2 = 0 ;
29234 char *kwnames[] = {
29235 (char *) "self",(char *) "x",(char *) "y", NULL
29236 };
29237
29238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29240 if (SWIG_arg_fail(1)) SWIG_fail;
29241 {
29242 arg2 = (int)(SWIG_As_int(obj1));
29243 if (SWIG_arg_fail(2)) SWIG_fail;
29244 }
29245 {
29246 arg3 = (int)(SWIG_As_int(obj2));
29247 if (SWIG_arg_fail(3)) SWIG_fail;
29248 }
29249 {
29250 PyThreadState* __tstate = wxPyBeginAllowThreads();
29251 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29252
29253 wxPyEndAllowThreads(__tstate);
29254 if (PyErr_Occurred()) SWIG_fail;
29255 }
29256 {
29257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29258 }
29259 return resultobj;
29260 fail:
29261 return NULL;
29262 }
29263
29264
29265 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29266 PyObject *resultobj;
29267 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29268 bool result;
29269 PyObject * obj0 = 0 ;
29270 char *kwnames[] = {
29271 (char *) "self", NULL
29272 };
29273
29274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29276 if (SWIG_arg_fail(1)) SWIG_fail;
29277 {
29278 PyThreadState* __tstate = wxPyBeginAllowThreads();
29279 result = (bool)(arg1)->GetData();
29280
29281 wxPyEndAllowThreads(__tstate);
29282 if (PyErr_Occurred()) SWIG_fail;
29283 }
29284 {
29285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29286 }
29287 return resultobj;
29288 fail:
29289 return NULL;
29290 }
29291
29292
29293 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29294 PyObject *resultobj;
29295 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29296 wxDragResult arg2 ;
29297 PyObject * obj0 = 0 ;
29298 PyObject * obj1 = 0 ;
29299 char *kwnames[] = {
29300 (char *) "self",(char *) "action", NULL
29301 };
29302
29303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29305 if (SWIG_arg_fail(1)) SWIG_fail;
29306 {
29307 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29308 if (SWIG_arg_fail(2)) SWIG_fail;
29309 }
29310 {
29311 PyThreadState* __tstate = wxPyBeginAllowThreads();
29312 (arg1)->SetDefaultAction((wxDragResult )arg2);
29313
29314 wxPyEndAllowThreads(__tstate);
29315 if (PyErr_Occurred()) SWIG_fail;
29316 }
29317 Py_INCREF(Py_None); resultobj = Py_None;
29318 return resultobj;
29319 fail:
29320 return NULL;
29321 }
29322
29323
29324 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29325 PyObject *resultobj;
29326 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29327 wxDragResult result;
29328 PyObject * obj0 = 0 ;
29329 char *kwnames[] = {
29330 (char *) "self", NULL
29331 };
29332
29333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29335 if (SWIG_arg_fail(1)) SWIG_fail;
29336 {
29337 PyThreadState* __tstate = wxPyBeginAllowThreads();
29338 result = (wxDragResult)(arg1)->GetDefaultAction();
29339
29340 wxPyEndAllowThreads(__tstate);
29341 if (PyErr_Occurred()) SWIG_fail;
29342 }
29343 resultobj = SWIG_From_int((result));
29344 return resultobj;
29345 fail:
29346 return NULL;
29347 }
29348
29349
29350 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29351 PyObject *obj;
29352 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29353 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29354 Py_INCREF(obj);
29355 return Py_BuildValue((char *)"");
29356 }
29357 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29358 PyObject *resultobj;
29359 wxPyTextDropTarget *result;
29360 char *kwnames[] = {
29361 NULL
29362 };
29363
29364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29365 {
29366 PyThreadState* __tstate = wxPyBeginAllowThreads();
29367 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29368
29369 wxPyEndAllowThreads(__tstate);
29370 if (PyErr_Occurred()) SWIG_fail;
29371 }
29372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29373 return resultobj;
29374 fail:
29375 return NULL;
29376 }
29377
29378
29379 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29380 PyObject *resultobj;
29381 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29382 PyObject *arg2 = (PyObject *) 0 ;
29383 PyObject *arg3 = (PyObject *) 0 ;
29384 PyObject * obj0 = 0 ;
29385 PyObject * obj1 = 0 ;
29386 PyObject * obj2 = 0 ;
29387 char *kwnames[] = {
29388 (char *) "self",(char *) "self",(char *) "_class", NULL
29389 };
29390
29391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29393 if (SWIG_arg_fail(1)) SWIG_fail;
29394 arg2 = obj1;
29395 arg3 = obj2;
29396 {
29397 PyThreadState* __tstate = wxPyBeginAllowThreads();
29398 (arg1)->_setCallbackInfo(arg2,arg3);
29399
29400 wxPyEndAllowThreads(__tstate);
29401 if (PyErr_Occurred()) SWIG_fail;
29402 }
29403 Py_INCREF(Py_None); resultobj = Py_None;
29404 return resultobj;
29405 fail:
29406 return NULL;
29407 }
29408
29409
29410 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29411 PyObject *resultobj;
29412 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29413 int arg2 ;
29414 int arg3 ;
29415 wxDragResult arg4 ;
29416 wxDragResult result;
29417 PyObject * obj0 = 0 ;
29418 PyObject * obj1 = 0 ;
29419 PyObject * obj2 = 0 ;
29420 PyObject * obj3 = 0 ;
29421 char *kwnames[] = {
29422 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29423 };
29424
29425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29427 if (SWIG_arg_fail(1)) SWIG_fail;
29428 {
29429 arg2 = (int)(SWIG_As_int(obj1));
29430 if (SWIG_arg_fail(2)) SWIG_fail;
29431 }
29432 {
29433 arg3 = (int)(SWIG_As_int(obj2));
29434 if (SWIG_arg_fail(3)) SWIG_fail;
29435 }
29436 {
29437 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29438 if (SWIG_arg_fail(4)) SWIG_fail;
29439 }
29440 {
29441 PyThreadState* __tstate = wxPyBeginAllowThreads();
29442 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29443
29444 wxPyEndAllowThreads(__tstate);
29445 if (PyErr_Occurred()) SWIG_fail;
29446 }
29447 resultobj = SWIG_From_int((result));
29448 return resultobj;
29449 fail:
29450 return NULL;
29451 }
29452
29453
29454 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29455 PyObject *resultobj;
29456 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29457 int arg2 ;
29458 int arg3 ;
29459 wxDragResult arg4 ;
29460 wxDragResult result;
29461 PyObject * obj0 = 0 ;
29462 PyObject * obj1 = 0 ;
29463 PyObject * obj2 = 0 ;
29464 PyObject * obj3 = 0 ;
29465 char *kwnames[] = {
29466 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29467 };
29468
29469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29471 if (SWIG_arg_fail(1)) SWIG_fail;
29472 {
29473 arg2 = (int)(SWIG_As_int(obj1));
29474 if (SWIG_arg_fail(2)) SWIG_fail;
29475 }
29476 {
29477 arg3 = (int)(SWIG_As_int(obj2));
29478 if (SWIG_arg_fail(3)) SWIG_fail;
29479 }
29480 {
29481 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29482 if (SWIG_arg_fail(4)) SWIG_fail;
29483 }
29484 {
29485 PyThreadState* __tstate = wxPyBeginAllowThreads();
29486 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29487
29488 wxPyEndAllowThreads(__tstate);
29489 if (PyErr_Occurred()) SWIG_fail;
29490 }
29491 resultobj = SWIG_From_int((result));
29492 return resultobj;
29493 fail:
29494 return NULL;
29495 }
29496
29497
29498 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29499 PyObject *resultobj;
29500 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29501 PyObject * obj0 = 0 ;
29502 char *kwnames[] = {
29503 (char *) "self", NULL
29504 };
29505
29506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29508 if (SWIG_arg_fail(1)) SWIG_fail;
29509 {
29510 PyThreadState* __tstate = wxPyBeginAllowThreads();
29511 (arg1)->base_OnLeave();
29512
29513 wxPyEndAllowThreads(__tstate);
29514 if (PyErr_Occurred()) SWIG_fail;
29515 }
29516 Py_INCREF(Py_None); resultobj = Py_None;
29517 return resultobj;
29518 fail:
29519 return NULL;
29520 }
29521
29522
29523 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29524 PyObject *resultobj;
29525 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29526 int arg2 ;
29527 int arg3 ;
29528 bool result;
29529 PyObject * obj0 = 0 ;
29530 PyObject * obj1 = 0 ;
29531 PyObject * obj2 = 0 ;
29532 char *kwnames[] = {
29533 (char *) "self",(char *) "x",(char *) "y", NULL
29534 };
29535
29536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29538 if (SWIG_arg_fail(1)) SWIG_fail;
29539 {
29540 arg2 = (int)(SWIG_As_int(obj1));
29541 if (SWIG_arg_fail(2)) SWIG_fail;
29542 }
29543 {
29544 arg3 = (int)(SWIG_As_int(obj2));
29545 if (SWIG_arg_fail(3)) SWIG_fail;
29546 }
29547 {
29548 PyThreadState* __tstate = wxPyBeginAllowThreads();
29549 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29550
29551 wxPyEndAllowThreads(__tstate);
29552 if (PyErr_Occurred()) SWIG_fail;
29553 }
29554 {
29555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29556 }
29557 return resultobj;
29558 fail:
29559 return NULL;
29560 }
29561
29562
29563 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29564 PyObject *resultobj;
29565 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29566 int arg2 ;
29567 int arg3 ;
29568 wxDragResult arg4 ;
29569 wxDragResult result;
29570 PyObject * obj0 = 0 ;
29571 PyObject * obj1 = 0 ;
29572 PyObject * obj2 = 0 ;
29573 PyObject * obj3 = 0 ;
29574 char *kwnames[] = {
29575 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29576 };
29577
29578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29580 if (SWIG_arg_fail(1)) SWIG_fail;
29581 {
29582 arg2 = (int)(SWIG_As_int(obj1));
29583 if (SWIG_arg_fail(2)) SWIG_fail;
29584 }
29585 {
29586 arg3 = (int)(SWIG_As_int(obj2));
29587 if (SWIG_arg_fail(3)) SWIG_fail;
29588 }
29589 {
29590 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29591 if (SWIG_arg_fail(4)) SWIG_fail;
29592 }
29593 {
29594 PyThreadState* __tstate = wxPyBeginAllowThreads();
29595 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29596
29597 wxPyEndAllowThreads(__tstate);
29598 if (PyErr_Occurred()) SWIG_fail;
29599 }
29600 resultobj = SWIG_From_int((result));
29601 return resultobj;
29602 fail:
29603 return NULL;
29604 }
29605
29606
29607 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29608 PyObject *obj;
29609 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29610 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29611 Py_INCREF(obj);
29612 return Py_BuildValue((char *)"");
29613 }
29614 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29615 PyObject *resultobj;
29616 wxPyFileDropTarget *result;
29617 char *kwnames[] = {
29618 NULL
29619 };
29620
29621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29622 {
29623 PyThreadState* __tstate = wxPyBeginAllowThreads();
29624 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29625
29626 wxPyEndAllowThreads(__tstate);
29627 if (PyErr_Occurred()) SWIG_fail;
29628 }
29629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29630 return resultobj;
29631 fail:
29632 return NULL;
29633 }
29634
29635
29636 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29637 PyObject *resultobj;
29638 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29639 PyObject *arg2 = (PyObject *) 0 ;
29640 PyObject *arg3 = (PyObject *) 0 ;
29641 PyObject * obj0 = 0 ;
29642 PyObject * obj1 = 0 ;
29643 PyObject * obj2 = 0 ;
29644 char *kwnames[] = {
29645 (char *) "self",(char *) "self",(char *) "_class", NULL
29646 };
29647
29648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29650 if (SWIG_arg_fail(1)) SWIG_fail;
29651 arg2 = obj1;
29652 arg3 = obj2;
29653 {
29654 PyThreadState* __tstate = wxPyBeginAllowThreads();
29655 (arg1)->_setCallbackInfo(arg2,arg3);
29656
29657 wxPyEndAllowThreads(__tstate);
29658 if (PyErr_Occurred()) SWIG_fail;
29659 }
29660 Py_INCREF(Py_None); resultobj = Py_None;
29661 return resultobj;
29662 fail:
29663 return NULL;
29664 }
29665
29666
29667 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29668 PyObject *resultobj;
29669 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29670 int arg2 ;
29671 int arg3 ;
29672 wxDragResult arg4 ;
29673 wxDragResult result;
29674 PyObject * obj0 = 0 ;
29675 PyObject * obj1 = 0 ;
29676 PyObject * obj2 = 0 ;
29677 PyObject * obj3 = 0 ;
29678 char *kwnames[] = {
29679 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29680 };
29681
29682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29684 if (SWIG_arg_fail(1)) SWIG_fail;
29685 {
29686 arg2 = (int)(SWIG_As_int(obj1));
29687 if (SWIG_arg_fail(2)) SWIG_fail;
29688 }
29689 {
29690 arg3 = (int)(SWIG_As_int(obj2));
29691 if (SWIG_arg_fail(3)) SWIG_fail;
29692 }
29693 {
29694 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29695 if (SWIG_arg_fail(4)) SWIG_fail;
29696 }
29697 {
29698 PyThreadState* __tstate = wxPyBeginAllowThreads();
29699 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29700
29701 wxPyEndAllowThreads(__tstate);
29702 if (PyErr_Occurred()) SWIG_fail;
29703 }
29704 resultobj = SWIG_From_int((result));
29705 return resultobj;
29706 fail:
29707 return NULL;
29708 }
29709
29710
29711 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29712 PyObject *resultobj;
29713 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29714 int arg2 ;
29715 int arg3 ;
29716 wxDragResult arg4 ;
29717 wxDragResult result;
29718 PyObject * obj0 = 0 ;
29719 PyObject * obj1 = 0 ;
29720 PyObject * obj2 = 0 ;
29721 PyObject * obj3 = 0 ;
29722 char *kwnames[] = {
29723 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29724 };
29725
29726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29728 if (SWIG_arg_fail(1)) SWIG_fail;
29729 {
29730 arg2 = (int)(SWIG_As_int(obj1));
29731 if (SWIG_arg_fail(2)) SWIG_fail;
29732 }
29733 {
29734 arg3 = (int)(SWIG_As_int(obj2));
29735 if (SWIG_arg_fail(3)) SWIG_fail;
29736 }
29737 {
29738 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29739 if (SWIG_arg_fail(4)) SWIG_fail;
29740 }
29741 {
29742 PyThreadState* __tstate = wxPyBeginAllowThreads();
29743 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29744
29745 wxPyEndAllowThreads(__tstate);
29746 if (PyErr_Occurred()) SWIG_fail;
29747 }
29748 resultobj = SWIG_From_int((result));
29749 return resultobj;
29750 fail:
29751 return NULL;
29752 }
29753
29754
29755 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29756 PyObject *resultobj;
29757 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29758 PyObject * obj0 = 0 ;
29759 char *kwnames[] = {
29760 (char *) "self", NULL
29761 };
29762
29763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29765 if (SWIG_arg_fail(1)) SWIG_fail;
29766 {
29767 PyThreadState* __tstate = wxPyBeginAllowThreads();
29768 (arg1)->base_OnLeave();
29769
29770 wxPyEndAllowThreads(__tstate);
29771 if (PyErr_Occurred()) SWIG_fail;
29772 }
29773 Py_INCREF(Py_None); resultobj = Py_None;
29774 return resultobj;
29775 fail:
29776 return NULL;
29777 }
29778
29779
29780 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29781 PyObject *resultobj;
29782 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29783 int arg2 ;
29784 int arg3 ;
29785 bool result;
29786 PyObject * obj0 = 0 ;
29787 PyObject * obj1 = 0 ;
29788 PyObject * obj2 = 0 ;
29789 char *kwnames[] = {
29790 (char *) "self",(char *) "x",(char *) "y", NULL
29791 };
29792
29793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29795 if (SWIG_arg_fail(1)) SWIG_fail;
29796 {
29797 arg2 = (int)(SWIG_As_int(obj1));
29798 if (SWIG_arg_fail(2)) SWIG_fail;
29799 }
29800 {
29801 arg3 = (int)(SWIG_As_int(obj2));
29802 if (SWIG_arg_fail(3)) SWIG_fail;
29803 }
29804 {
29805 PyThreadState* __tstate = wxPyBeginAllowThreads();
29806 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29807
29808 wxPyEndAllowThreads(__tstate);
29809 if (PyErr_Occurred()) SWIG_fail;
29810 }
29811 {
29812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29813 }
29814 return resultobj;
29815 fail:
29816 return NULL;
29817 }
29818
29819
29820 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29821 PyObject *resultobj;
29822 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29823 int arg2 ;
29824 int arg3 ;
29825 wxDragResult arg4 ;
29826 wxDragResult result;
29827 PyObject * obj0 = 0 ;
29828 PyObject * obj1 = 0 ;
29829 PyObject * obj2 = 0 ;
29830 PyObject * obj3 = 0 ;
29831 char *kwnames[] = {
29832 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29833 };
29834
29835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29837 if (SWIG_arg_fail(1)) SWIG_fail;
29838 {
29839 arg2 = (int)(SWIG_As_int(obj1));
29840 if (SWIG_arg_fail(2)) SWIG_fail;
29841 }
29842 {
29843 arg3 = (int)(SWIG_As_int(obj2));
29844 if (SWIG_arg_fail(3)) SWIG_fail;
29845 }
29846 {
29847 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29848 if (SWIG_arg_fail(4)) SWIG_fail;
29849 }
29850 {
29851 PyThreadState* __tstate = wxPyBeginAllowThreads();
29852 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29853
29854 wxPyEndAllowThreads(__tstate);
29855 if (PyErr_Occurred()) SWIG_fail;
29856 }
29857 resultobj = SWIG_From_int((result));
29858 return resultobj;
29859 fail:
29860 return NULL;
29861 }
29862
29863
29864 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29865 PyObject *obj;
29866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29867 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29868 Py_INCREF(obj);
29869 return Py_BuildValue((char *)"");
29870 }
29871 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29872 PyObject *resultobj;
29873 wxClipboard *result;
29874 char *kwnames[] = {
29875 NULL
29876 };
29877
29878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29879 {
29880 PyThreadState* __tstate = wxPyBeginAllowThreads();
29881 result = (wxClipboard *)new wxClipboard();
29882
29883 wxPyEndAllowThreads(__tstate);
29884 if (PyErr_Occurred()) SWIG_fail;
29885 }
29886 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29887 return resultobj;
29888 fail:
29889 return NULL;
29890 }
29891
29892
29893 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29894 PyObject *resultobj;
29895 wxClipboard *arg1 = (wxClipboard *) 0 ;
29896 PyObject * obj0 = 0 ;
29897 char *kwnames[] = {
29898 (char *) "self", NULL
29899 };
29900
29901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29903 if (SWIG_arg_fail(1)) SWIG_fail;
29904 {
29905 PyThreadState* __tstate = wxPyBeginAllowThreads();
29906 delete arg1;
29907
29908 wxPyEndAllowThreads(__tstate);
29909 if (PyErr_Occurred()) SWIG_fail;
29910 }
29911 Py_INCREF(Py_None); resultobj = Py_None;
29912 return resultobj;
29913 fail:
29914 return NULL;
29915 }
29916
29917
29918 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29919 PyObject *resultobj;
29920 wxClipboard *arg1 = (wxClipboard *) 0 ;
29921 bool result;
29922 PyObject * obj0 = 0 ;
29923 char *kwnames[] = {
29924 (char *) "self", NULL
29925 };
29926
29927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29929 if (SWIG_arg_fail(1)) SWIG_fail;
29930 {
29931 PyThreadState* __tstate = wxPyBeginAllowThreads();
29932 result = (bool)(arg1)->Open();
29933
29934 wxPyEndAllowThreads(__tstate);
29935 if (PyErr_Occurred()) SWIG_fail;
29936 }
29937 {
29938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29939 }
29940 return resultobj;
29941 fail:
29942 return NULL;
29943 }
29944
29945
29946 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29947 PyObject *resultobj;
29948 wxClipboard *arg1 = (wxClipboard *) 0 ;
29949 PyObject * obj0 = 0 ;
29950 char *kwnames[] = {
29951 (char *) "self", NULL
29952 };
29953
29954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29956 if (SWIG_arg_fail(1)) SWIG_fail;
29957 {
29958 PyThreadState* __tstate = wxPyBeginAllowThreads();
29959 (arg1)->Close();
29960
29961 wxPyEndAllowThreads(__tstate);
29962 if (PyErr_Occurred()) SWIG_fail;
29963 }
29964 Py_INCREF(Py_None); resultobj = Py_None;
29965 return resultobj;
29966 fail:
29967 return NULL;
29968 }
29969
29970
29971 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29972 PyObject *resultobj;
29973 wxClipboard *arg1 = (wxClipboard *) 0 ;
29974 bool result;
29975 PyObject * obj0 = 0 ;
29976 char *kwnames[] = {
29977 (char *) "self", NULL
29978 };
29979
29980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29982 if (SWIG_arg_fail(1)) SWIG_fail;
29983 {
29984 PyThreadState* __tstate = wxPyBeginAllowThreads();
29985 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29986
29987 wxPyEndAllowThreads(__tstate);
29988 if (PyErr_Occurred()) SWIG_fail;
29989 }
29990 {
29991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29992 }
29993 return resultobj;
29994 fail:
29995 return NULL;
29996 }
29997
29998
29999 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
30000 PyObject *resultobj;
30001 wxClipboard *arg1 = (wxClipboard *) 0 ;
30002 wxDataObject *arg2 = (wxDataObject *) 0 ;
30003 bool result;
30004 PyObject * obj0 = 0 ;
30005 PyObject * obj1 = 0 ;
30006 char *kwnames[] = {
30007 (char *) "self",(char *) "data", NULL
30008 };
30009
30010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
30011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30012 if (SWIG_arg_fail(1)) SWIG_fail;
30013 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30014 if (SWIG_arg_fail(2)) SWIG_fail;
30015 {
30016 PyThreadState* __tstate = wxPyBeginAllowThreads();
30017 result = (bool)(arg1)->AddData(arg2);
30018
30019 wxPyEndAllowThreads(__tstate);
30020 if (PyErr_Occurred()) SWIG_fail;
30021 }
30022 {
30023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30024 }
30025 return resultobj;
30026 fail:
30027 return NULL;
30028 }
30029
30030
30031 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
30032 PyObject *resultobj;
30033 wxClipboard *arg1 = (wxClipboard *) 0 ;
30034 wxDataObject *arg2 = (wxDataObject *) 0 ;
30035 bool result;
30036 PyObject * obj0 = 0 ;
30037 PyObject * obj1 = 0 ;
30038 char *kwnames[] = {
30039 (char *) "self",(char *) "data", NULL
30040 };
30041
30042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
30043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30044 if (SWIG_arg_fail(1)) SWIG_fail;
30045 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30046 if (SWIG_arg_fail(2)) SWIG_fail;
30047 {
30048 PyThreadState* __tstate = wxPyBeginAllowThreads();
30049 result = (bool)(arg1)->SetData(arg2);
30050
30051 wxPyEndAllowThreads(__tstate);
30052 if (PyErr_Occurred()) SWIG_fail;
30053 }
30054 {
30055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30056 }
30057 return resultobj;
30058 fail:
30059 return NULL;
30060 }
30061
30062
30063 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
30064 PyObject *resultobj;
30065 wxClipboard *arg1 = (wxClipboard *) 0 ;
30066 wxDataFormat *arg2 = 0 ;
30067 bool result;
30068 PyObject * obj0 = 0 ;
30069 PyObject * obj1 = 0 ;
30070 char *kwnames[] = {
30071 (char *) "self",(char *) "format", NULL
30072 };
30073
30074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
30075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30076 if (SWIG_arg_fail(1)) SWIG_fail;
30077 {
30078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
30079 if (SWIG_arg_fail(2)) SWIG_fail;
30080 if (arg2 == NULL) {
30081 SWIG_null_ref("wxDataFormat");
30082 }
30083 if (SWIG_arg_fail(2)) SWIG_fail;
30084 }
30085 {
30086 PyThreadState* __tstate = wxPyBeginAllowThreads();
30087 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
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_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30102 PyObject *resultobj;
30103 wxClipboard *arg1 = (wxClipboard *) 0 ;
30104 wxDataObject *arg2 = 0 ;
30105 bool result;
30106 PyObject * obj0 = 0 ;
30107 PyObject * obj1 = 0 ;
30108 char *kwnames[] = {
30109 (char *) "self",(char *) "data", NULL
30110 };
30111
30112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30114 if (SWIG_arg_fail(1)) SWIG_fail;
30115 {
30116 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30117 if (SWIG_arg_fail(2)) SWIG_fail;
30118 if (arg2 == NULL) {
30119 SWIG_null_ref("wxDataObject");
30120 }
30121 if (SWIG_arg_fail(2)) SWIG_fail;
30122 }
30123 {
30124 PyThreadState* __tstate = wxPyBeginAllowThreads();
30125 result = (bool)(arg1)->GetData(*arg2);
30126
30127 wxPyEndAllowThreads(__tstate);
30128 if (PyErr_Occurred()) SWIG_fail;
30129 }
30130 {
30131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30132 }
30133 return resultobj;
30134 fail:
30135 return NULL;
30136 }
30137
30138
30139 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30140 PyObject *resultobj;
30141 wxClipboard *arg1 = (wxClipboard *) 0 ;
30142 PyObject * obj0 = 0 ;
30143 char *kwnames[] = {
30144 (char *) "self", NULL
30145 };
30146
30147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30149 if (SWIG_arg_fail(1)) SWIG_fail;
30150 {
30151 PyThreadState* __tstate = wxPyBeginAllowThreads();
30152 (arg1)->Clear();
30153
30154 wxPyEndAllowThreads(__tstate);
30155 if (PyErr_Occurred()) SWIG_fail;
30156 }
30157 Py_INCREF(Py_None); resultobj = Py_None;
30158 return resultobj;
30159 fail:
30160 return NULL;
30161 }
30162
30163
30164 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30165 PyObject *resultobj;
30166 wxClipboard *arg1 = (wxClipboard *) 0 ;
30167 bool result;
30168 PyObject * obj0 = 0 ;
30169 char *kwnames[] = {
30170 (char *) "self", NULL
30171 };
30172
30173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30175 if (SWIG_arg_fail(1)) SWIG_fail;
30176 {
30177 PyThreadState* __tstate = wxPyBeginAllowThreads();
30178 result = (bool)(arg1)->Flush();
30179
30180 wxPyEndAllowThreads(__tstate);
30181 if (PyErr_Occurred()) SWIG_fail;
30182 }
30183 {
30184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30185 }
30186 return resultobj;
30187 fail:
30188 return NULL;
30189 }
30190
30191
30192 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30193 PyObject *resultobj;
30194 wxClipboard *arg1 = (wxClipboard *) 0 ;
30195 bool arg2 = (bool) true ;
30196 PyObject * obj0 = 0 ;
30197 PyObject * obj1 = 0 ;
30198 char *kwnames[] = {
30199 (char *) "self",(char *) "primary", NULL
30200 };
30201
30202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30204 if (SWIG_arg_fail(1)) SWIG_fail;
30205 if (obj1) {
30206 {
30207 arg2 = (bool)(SWIG_As_bool(obj1));
30208 if (SWIG_arg_fail(2)) SWIG_fail;
30209 }
30210 }
30211 {
30212 PyThreadState* __tstate = wxPyBeginAllowThreads();
30213 (arg1)->UsePrimarySelection(arg2);
30214
30215 wxPyEndAllowThreads(__tstate);
30216 if (PyErr_Occurred()) SWIG_fail;
30217 }
30218 Py_INCREF(Py_None); resultobj = Py_None;
30219 return resultobj;
30220 fail:
30221 return NULL;
30222 }
30223
30224
30225 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30226 PyObject *resultobj;
30227 wxClipboard *result;
30228 char *kwnames[] = {
30229 NULL
30230 };
30231
30232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30233 {
30234 PyThreadState* __tstate = wxPyBeginAllowThreads();
30235 result = (wxClipboard *)wxClipboard::Get();
30236
30237 wxPyEndAllowThreads(__tstate);
30238 if (PyErr_Occurred()) SWIG_fail;
30239 }
30240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30241 return resultobj;
30242 fail:
30243 return NULL;
30244 }
30245
30246
30247 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30248 PyObject *obj;
30249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30250 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30251 Py_INCREF(obj);
30252 return Py_BuildValue((char *)"");
30253 }
30254 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30255 PyObject *resultobj;
30256 wxClipboard *arg1 = (wxClipboard *) NULL ;
30257 wxClipboardLocker *result;
30258 PyObject * obj0 = 0 ;
30259 char *kwnames[] = {
30260 (char *) "clipboard", NULL
30261 };
30262
30263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30264 if (obj0) {
30265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30266 if (SWIG_arg_fail(1)) SWIG_fail;
30267 }
30268 {
30269 PyThreadState* __tstate = wxPyBeginAllowThreads();
30270 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30271
30272 wxPyEndAllowThreads(__tstate);
30273 if (PyErr_Occurred()) SWIG_fail;
30274 }
30275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30276 return resultobj;
30277 fail:
30278 return NULL;
30279 }
30280
30281
30282 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30283 PyObject *resultobj;
30284 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30285 PyObject * obj0 = 0 ;
30286 char *kwnames[] = {
30287 (char *) "self", NULL
30288 };
30289
30290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30292 if (SWIG_arg_fail(1)) SWIG_fail;
30293 {
30294 PyThreadState* __tstate = wxPyBeginAllowThreads();
30295 delete arg1;
30296
30297 wxPyEndAllowThreads(__tstate);
30298 if (PyErr_Occurred()) SWIG_fail;
30299 }
30300 Py_INCREF(Py_None); resultobj = Py_None;
30301 return resultobj;
30302 fail:
30303 return NULL;
30304 }
30305
30306
30307 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30308 PyObject *resultobj;
30309 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30310 bool result;
30311 PyObject * obj0 = 0 ;
30312 char *kwnames[] = {
30313 (char *) "self", NULL
30314 };
30315
30316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30318 if (SWIG_arg_fail(1)) SWIG_fail;
30319 {
30320 PyThreadState* __tstate = wxPyBeginAllowThreads();
30321 result = (bool)wxClipboardLocker___nonzero__(arg1);
30322
30323 wxPyEndAllowThreads(__tstate);
30324 if (PyErr_Occurred()) SWIG_fail;
30325 }
30326 {
30327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30328 }
30329 return resultobj;
30330 fail:
30331 return NULL;
30332 }
30333
30334
30335 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30336 PyObject *obj;
30337 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30338 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30339 Py_INCREF(obj);
30340 return Py_BuildValue((char *)"");
30341 }
30342 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30343 PyObject *resultobj;
30344 int arg1 = (int) 0 ;
30345 int arg2 = (int) 0 ;
30346 int arg3 = (int) 0 ;
30347 int arg4 = (int) 0 ;
30348 wxVideoMode *result;
30349 PyObject * obj0 = 0 ;
30350 PyObject * obj1 = 0 ;
30351 PyObject * obj2 = 0 ;
30352 PyObject * obj3 = 0 ;
30353 char *kwnames[] = {
30354 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30355 };
30356
30357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30358 if (obj0) {
30359 {
30360 arg1 = (int)(SWIG_As_int(obj0));
30361 if (SWIG_arg_fail(1)) SWIG_fail;
30362 }
30363 }
30364 if (obj1) {
30365 {
30366 arg2 = (int)(SWIG_As_int(obj1));
30367 if (SWIG_arg_fail(2)) SWIG_fail;
30368 }
30369 }
30370 if (obj2) {
30371 {
30372 arg3 = (int)(SWIG_As_int(obj2));
30373 if (SWIG_arg_fail(3)) SWIG_fail;
30374 }
30375 }
30376 if (obj3) {
30377 {
30378 arg4 = (int)(SWIG_As_int(obj3));
30379 if (SWIG_arg_fail(4)) SWIG_fail;
30380 }
30381 }
30382 {
30383 PyThreadState* __tstate = wxPyBeginAllowThreads();
30384 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30385
30386 wxPyEndAllowThreads(__tstate);
30387 if (PyErr_Occurred()) SWIG_fail;
30388 }
30389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30397 PyObject *resultobj;
30398 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30399 PyObject * obj0 = 0 ;
30400 char *kwnames[] = {
30401 (char *) "self", NULL
30402 };
30403
30404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30406 if (SWIG_arg_fail(1)) SWIG_fail;
30407 {
30408 PyThreadState* __tstate = wxPyBeginAllowThreads();
30409 delete arg1;
30410
30411 wxPyEndAllowThreads(__tstate);
30412 if (PyErr_Occurred()) SWIG_fail;
30413 }
30414 Py_INCREF(Py_None); resultobj = Py_None;
30415 return resultobj;
30416 fail:
30417 return NULL;
30418 }
30419
30420
30421 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30422 PyObject *resultobj;
30423 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30424 wxVideoMode *arg2 = 0 ;
30425 bool result;
30426 PyObject * obj0 = 0 ;
30427 PyObject * obj1 = 0 ;
30428 char *kwnames[] = {
30429 (char *) "self",(char *) "other", NULL
30430 };
30431
30432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30434 if (SWIG_arg_fail(1)) SWIG_fail;
30435 {
30436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30437 if (SWIG_arg_fail(2)) SWIG_fail;
30438 if (arg2 == NULL) {
30439 SWIG_null_ref("wxVideoMode");
30440 }
30441 if (SWIG_arg_fail(2)) SWIG_fail;
30442 }
30443 {
30444 PyThreadState* __tstate = wxPyBeginAllowThreads();
30445 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30446
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 {
30451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30452 }
30453 return resultobj;
30454 fail:
30455 return NULL;
30456 }
30457
30458
30459 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30460 PyObject *resultobj;
30461 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30462 int result;
30463 PyObject * obj0 = 0 ;
30464 char *kwnames[] = {
30465 (char *) "self", NULL
30466 };
30467
30468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30470 if (SWIG_arg_fail(1)) SWIG_fail;
30471 {
30472 PyThreadState* __tstate = wxPyBeginAllowThreads();
30473 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30474
30475 wxPyEndAllowThreads(__tstate);
30476 if (PyErr_Occurred()) SWIG_fail;
30477 }
30478 {
30479 resultobj = SWIG_From_int((int)(result));
30480 }
30481 return resultobj;
30482 fail:
30483 return NULL;
30484 }
30485
30486
30487 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30488 PyObject *resultobj;
30489 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30490 int result;
30491 PyObject * obj0 = 0 ;
30492 char *kwnames[] = {
30493 (char *) "self", NULL
30494 };
30495
30496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30498 if (SWIG_arg_fail(1)) SWIG_fail;
30499 {
30500 PyThreadState* __tstate = wxPyBeginAllowThreads();
30501 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30502
30503 wxPyEndAllowThreads(__tstate);
30504 if (PyErr_Occurred()) SWIG_fail;
30505 }
30506 {
30507 resultobj = SWIG_From_int((int)(result));
30508 }
30509 return resultobj;
30510 fail:
30511 return NULL;
30512 }
30513
30514
30515 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30516 PyObject *resultobj;
30517 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30518 int result;
30519 PyObject * obj0 = 0 ;
30520 char *kwnames[] = {
30521 (char *) "self", NULL
30522 };
30523
30524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30526 if (SWIG_arg_fail(1)) SWIG_fail;
30527 {
30528 PyThreadState* __tstate = wxPyBeginAllowThreads();
30529 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30530
30531 wxPyEndAllowThreads(__tstate);
30532 if (PyErr_Occurred()) SWIG_fail;
30533 }
30534 {
30535 resultobj = SWIG_From_int((int)(result));
30536 }
30537 return resultobj;
30538 fail:
30539 return NULL;
30540 }
30541
30542
30543 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30544 PyObject *resultobj;
30545 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30546 bool result;
30547 PyObject * obj0 = 0 ;
30548 char *kwnames[] = {
30549 (char *) "self", NULL
30550 };
30551
30552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30554 if (SWIG_arg_fail(1)) SWIG_fail;
30555 {
30556 PyThreadState* __tstate = wxPyBeginAllowThreads();
30557 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30558
30559 wxPyEndAllowThreads(__tstate);
30560 if (PyErr_Occurred()) SWIG_fail;
30561 }
30562 {
30563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30564 }
30565 return resultobj;
30566 fail:
30567 return NULL;
30568 }
30569
30570
30571 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30572 PyObject *resultobj;
30573 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30574 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30575 bool result;
30576 PyObject * obj0 = 0 ;
30577 PyObject * obj1 = 0 ;
30578 char *kwnames[] = {
30579 (char *) "self",(char *) "other", NULL
30580 };
30581
30582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30584 if (SWIG_arg_fail(1)) SWIG_fail;
30585 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30586 if (SWIG_arg_fail(2)) SWIG_fail;
30587 {
30588 PyThreadState* __tstate = wxPyBeginAllowThreads();
30589 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30590
30591 wxPyEndAllowThreads(__tstate);
30592 if (PyErr_Occurred()) SWIG_fail;
30593 }
30594 {
30595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30596 }
30597 return resultobj;
30598 fail:
30599 return NULL;
30600 }
30601
30602
30603 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30604 PyObject *resultobj;
30605 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30606 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30607 bool result;
30608 PyObject * obj0 = 0 ;
30609 PyObject * obj1 = 0 ;
30610 char *kwnames[] = {
30611 (char *) "self",(char *) "other", NULL
30612 };
30613
30614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30616 if (SWIG_arg_fail(1)) SWIG_fail;
30617 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30618 if (SWIG_arg_fail(2)) SWIG_fail;
30619 {
30620 PyThreadState* __tstate = wxPyBeginAllowThreads();
30621 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30622
30623 wxPyEndAllowThreads(__tstate);
30624 if (PyErr_Occurred()) SWIG_fail;
30625 }
30626 {
30627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30628 }
30629 return resultobj;
30630 fail:
30631 return NULL;
30632 }
30633
30634
30635 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30636 PyObject *resultobj;
30637 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30638 int arg2 ;
30639 PyObject * obj0 = 0 ;
30640 PyObject * obj1 = 0 ;
30641 char *kwnames[] = {
30642 (char *) "self",(char *) "w", NULL
30643 };
30644
30645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30647 if (SWIG_arg_fail(1)) SWIG_fail;
30648 {
30649 arg2 = (int)(SWIG_As_int(obj1));
30650 if (SWIG_arg_fail(2)) SWIG_fail;
30651 }
30652 if (arg1) (arg1)->w = arg2;
30653
30654 Py_INCREF(Py_None); resultobj = Py_None;
30655 return resultobj;
30656 fail:
30657 return NULL;
30658 }
30659
30660
30661 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30662 PyObject *resultobj;
30663 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30664 int result;
30665 PyObject * obj0 = 0 ;
30666 char *kwnames[] = {
30667 (char *) "self", NULL
30668 };
30669
30670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30672 if (SWIG_arg_fail(1)) SWIG_fail;
30673 result = (int) ((arg1)->w);
30674
30675 {
30676 resultobj = SWIG_From_int((int)(result));
30677 }
30678 return resultobj;
30679 fail:
30680 return NULL;
30681 }
30682
30683
30684 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30685 PyObject *resultobj;
30686 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30687 int arg2 ;
30688 PyObject * obj0 = 0 ;
30689 PyObject * obj1 = 0 ;
30690 char *kwnames[] = {
30691 (char *) "self",(char *) "h", NULL
30692 };
30693
30694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30696 if (SWIG_arg_fail(1)) SWIG_fail;
30697 {
30698 arg2 = (int)(SWIG_As_int(obj1));
30699 if (SWIG_arg_fail(2)) SWIG_fail;
30700 }
30701 if (arg1) (arg1)->h = arg2;
30702
30703 Py_INCREF(Py_None); resultobj = Py_None;
30704 return resultobj;
30705 fail:
30706 return NULL;
30707 }
30708
30709
30710 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30711 PyObject *resultobj;
30712 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30713 int result;
30714 PyObject * obj0 = 0 ;
30715 char *kwnames[] = {
30716 (char *) "self", NULL
30717 };
30718
30719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30721 if (SWIG_arg_fail(1)) SWIG_fail;
30722 result = (int) ((arg1)->h);
30723
30724 {
30725 resultobj = SWIG_From_int((int)(result));
30726 }
30727 return resultobj;
30728 fail:
30729 return NULL;
30730 }
30731
30732
30733 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30734 PyObject *resultobj;
30735 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30736 int arg2 ;
30737 PyObject * obj0 = 0 ;
30738 PyObject * obj1 = 0 ;
30739 char *kwnames[] = {
30740 (char *) "self",(char *) "bpp", NULL
30741 };
30742
30743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30745 if (SWIG_arg_fail(1)) SWIG_fail;
30746 {
30747 arg2 = (int)(SWIG_As_int(obj1));
30748 if (SWIG_arg_fail(2)) SWIG_fail;
30749 }
30750 if (arg1) (arg1)->bpp = arg2;
30751
30752 Py_INCREF(Py_None); resultobj = Py_None;
30753 return resultobj;
30754 fail:
30755 return NULL;
30756 }
30757
30758
30759 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30760 PyObject *resultobj;
30761 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30762 int result;
30763 PyObject * obj0 = 0 ;
30764 char *kwnames[] = {
30765 (char *) "self", NULL
30766 };
30767
30768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30770 if (SWIG_arg_fail(1)) SWIG_fail;
30771 result = (int) ((arg1)->bpp);
30772
30773 {
30774 resultobj = SWIG_From_int((int)(result));
30775 }
30776 return resultobj;
30777 fail:
30778 return NULL;
30779 }
30780
30781
30782 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30783 PyObject *resultobj;
30784 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30785 int arg2 ;
30786 PyObject * obj0 = 0 ;
30787 PyObject * obj1 = 0 ;
30788 char *kwnames[] = {
30789 (char *) "self",(char *) "refresh", NULL
30790 };
30791
30792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30794 if (SWIG_arg_fail(1)) SWIG_fail;
30795 {
30796 arg2 = (int)(SWIG_As_int(obj1));
30797 if (SWIG_arg_fail(2)) SWIG_fail;
30798 }
30799 if (arg1) (arg1)->refresh = arg2;
30800
30801 Py_INCREF(Py_None); resultobj = Py_None;
30802 return resultobj;
30803 fail:
30804 return NULL;
30805 }
30806
30807
30808 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30809 PyObject *resultobj;
30810 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30811 int result;
30812 PyObject * obj0 = 0 ;
30813 char *kwnames[] = {
30814 (char *) "self", NULL
30815 };
30816
30817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30819 if (SWIG_arg_fail(1)) SWIG_fail;
30820 result = (int) ((arg1)->refresh);
30821
30822 {
30823 resultobj = SWIG_From_int((int)(result));
30824 }
30825 return resultobj;
30826 fail:
30827 return NULL;
30828 }
30829
30830
30831 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30832 PyObject *obj;
30833 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30834 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30835 Py_INCREF(obj);
30836 return Py_BuildValue((char *)"");
30837 }
30838 static int _wrap_DefaultVideoMode_set(PyObject *) {
30839 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30840 return 1;
30841 }
30842
30843
30844 static PyObject *_wrap_DefaultVideoMode_get(void) {
30845 PyObject *pyobj;
30846
30847 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30848 return pyobj;
30849 }
30850
30851
30852 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30853 PyObject *resultobj;
30854 size_t arg1 = (size_t) 0 ;
30855 wxDisplay *result;
30856 PyObject * obj0 = 0 ;
30857 char *kwnames[] = {
30858 (char *) "index", NULL
30859 };
30860
30861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30862 if (obj0) {
30863 {
30864 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30865 if (SWIG_arg_fail(1)) SWIG_fail;
30866 }
30867 }
30868 {
30869 PyThreadState* __tstate = wxPyBeginAllowThreads();
30870 result = (wxDisplay *)new wxDisplay(arg1);
30871
30872 wxPyEndAllowThreads(__tstate);
30873 if (PyErr_Occurred()) SWIG_fail;
30874 }
30875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30876 return resultobj;
30877 fail:
30878 return NULL;
30879 }
30880
30881
30882 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30883 PyObject *resultobj;
30884 wxDisplay *arg1 = (wxDisplay *) 0 ;
30885 PyObject * obj0 = 0 ;
30886 char *kwnames[] = {
30887 (char *) "self", NULL
30888 };
30889
30890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30892 if (SWIG_arg_fail(1)) SWIG_fail;
30893 {
30894 PyThreadState* __tstate = wxPyBeginAllowThreads();
30895 delete arg1;
30896
30897 wxPyEndAllowThreads(__tstate);
30898 if (PyErr_Occurred()) SWIG_fail;
30899 }
30900 Py_INCREF(Py_None); resultobj = Py_None;
30901 return resultobj;
30902 fail:
30903 return NULL;
30904 }
30905
30906
30907 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30908 PyObject *resultobj;
30909 size_t result;
30910 char *kwnames[] = {
30911 NULL
30912 };
30913
30914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30915 {
30916 PyThreadState* __tstate = wxPyBeginAllowThreads();
30917 result = (size_t)wxDisplay::GetCount();
30918
30919 wxPyEndAllowThreads(__tstate);
30920 if (PyErr_Occurred()) SWIG_fail;
30921 }
30922 {
30923 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30924 }
30925 return resultobj;
30926 fail:
30927 return NULL;
30928 }
30929
30930
30931 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30932 PyObject *resultobj;
30933 wxPoint *arg1 = 0 ;
30934 int result;
30935 wxPoint temp1 ;
30936 PyObject * obj0 = 0 ;
30937 char *kwnames[] = {
30938 (char *) "pt", NULL
30939 };
30940
30941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30942 {
30943 arg1 = &temp1;
30944 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30945 }
30946 {
30947 PyThreadState* __tstate = wxPyBeginAllowThreads();
30948 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30949
30950 wxPyEndAllowThreads(__tstate);
30951 if (PyErr_Occurred()) SWIG_fail;
30952 }
30953 {
30954 resultobj = SWIG_From_int((int)(result));
30955 }
30956 return resultobj;
30957 fail:
30958 return NULL;
30959 }
30960
30961
30962 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30963 PyObject *resultobj;
30964 wxWindow *arg1 = (wxWindow *) 0 ;
30965 int result;
30966 PyObject * obj0 = 0 ;
30967 char *kwnames[] = {
30968 (char *) "window", NULL
30969 };
30970
30971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30973 if (SWIG_arg_fail(1)) SWIG_fail;
30974 {
30975 PyThreadState* __tstate = wxPyBeginAllowThreads();
30976 result = (int)Display_GetFromWindow(arg1);
30977
30978 wxPyEndAllowThreads(__tstate);
30979 if (PyErr_Occurred()) SWIG_fail;
30980 }
30981 {
30982 resultobj = SWIG_From_int((int)(result));
30983 }
30984 return resultobj;
30985 fail:
30986 return NULL;
30987 }
30988
30989
30990 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30991 PyObject *resultobj;
30992 wxDisplay *arg1 = (wxDisplay *) 0 ;
30993 bool result;
30994 PyObject * obj0 = 0 ;
30995 char *kwnames[] = {
30996 (char *) "self", NULL
30997 };
30998
30999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
31000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31001 if (SWIG_arg_fail(1)) SWIG_fail;
31002 {
31003 PyThreadState* __tstate = wxPyBeginAllowThreads();
31004 result = (bool)((wxDisplay const *)arg1)->IsOk();
31005
31006 wxPyEndAllowThreads(__tstate);
31007 if (PyErr_Occurred()) SWIG_fail;
31008 }
31009 {
31010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31011 }
31012 return resultobj;
31013 fail:
31014 return NULL;
31015 }
31016
31017
31018 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
31019 PyObject *resultobj;
31020 wxDisplay *arg1 = (wxDisplay *) 0 ;
31021 wxRect result;
31022 PyObject * obj0 = 0 ;
31023 char *kwnames[] = {
31024 (char *) "self", NULL
31025 };
31026
31027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
31028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31029 if (SWIG_arg_fail(1)) SWIG_fail;
31030 {
31031 PyThreadState* __tstate = wxPyBeginAllowThreads();
31032 result = ((wxDisplay const *)arg1)->GetGeometry();
31033
31034 wxPyEndAllowThreads(__tstate);
31035 if (PyErr_Occurred()) SWIG_fail;
31036 }
31037 {
31038 wxRect * resultptr;
31039 resultptr = new wxRect((wxRect &)(result));
31040 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
31041 }
31042 return resultobj;
31043 fail:
31044 return NULL;
31045 }
31046
31047
31048 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
31049 PyObject *resultobj;
31050 wxDisplay *arg1 = (wxDisplay *) 0 ;
31051 wxString result;
31052 PyObject * obj0 = 0 ;
31053 char *kwnames[] = {
31054 (char *) "self", NULL
31055 };
31056
31057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
31058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31059 if (SWIG_arg_fail(1)) SWIG_fail;
31060 {
31061 PyThreadState* __tstate = wxPyBeginAllowThreads();
31062 result = ((wxDisplay const *)arg1)->GetName();
31063
31064 wxPyEndAllowThreads(__tstate);
31065 if (PyErr_Occurred()) SWIG_fail;
31066 }
31067 {
31068 #if wxUSE_UNICODE
31069 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31070 #else
31071 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31072 #endif
31073 }
31074 return resultobj;
31075 fail:
31076 return NULL;
31077 }
31078
31079
31080 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
31081 PyObject *resultobj;
31082 wxDisplay *arg1 = (wxDisplay *) 0 ;
31083 bool result;
31084 PyObject * obj0 = 0 ;
31085 char *kwnames[] = {
31086 (char *) "self", NULL
31087 };
31088
31089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
31090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31091 if (SWIG_arg_fail(1)) SWIG_fail;
31092 {
31093 PyThreadState* __tstate = wxPyBeginAllowThreads();
31094 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31095
31096 wxPyEndAllowThreads(__tstate);
31097 if (PyErr_Occurred()) SWIG_fail;
31098 }
31099 {
31100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31101 }
31102 return resultobj;
31103 fail:
31104 return NULL;
31105 }
31106
31107
31108 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31109 PyObject *resultobj;
31110 wxDisplay *arg1 = (wxDisplay *) 0 ;
31111 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31112 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31113 PyObject *result;
31114 PyObject * obj0 = 0 ;
31115 PyObject * obj1 = 0 ;
31116 char *kwnames[] = {
31117 (char *) "self",(char *) "mode", NULL
31118 };
31119
31120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31122 if (SWIG_arg_fail(1)) SWIG_fail;
31123 if (obj1) {
31124 {
31125 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31126 if (SWIG_arg_fail(2)) SWIG_fail;
31127 if (arg2 == NULL) {
31128 SWIG_null_ref("wxVideoMode");
31129 }
31130 if (SWIG_arg_fail(2)) SWIG_fail;
31131 }
31132 }
31133 {
31134 PyThreadState* __tstate = wxPyBeginAllowThreads();
31135 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31136
31137 wxPyEndAllowThreads(__tstate);
31138 if (PyErr_Occurred()) SWIG_fail;
31139 }
31140 resultobj = result;
31141 return resultobj;
31142 fail:
31143 return NULL;
31144 }
31145
31146
31147 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31148 PyObject *resultobj;
31149 wxDisplay *arg1 = (wxDisplay *) 0 ;
31150 wxVideoMode result;
31151 PyObject * obj0 = 0 ;
31152 char *kwnames[] = {
31153 (char *) "self", NULL
31154 };
31155
31156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31158 if (SWIG_arg_fail(1)) SWIG_fail;
31159 {
31160 PyThreadState* __tstate = wxPyBeginAllowThreads();
31161 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31162
31163 wxPyEndAllowThreads(__tstate);
31164 if (PyErr_Occurred()) SWIG_fail;
31165 }
31166 {
31167 wxVideoMode * resultptr;
31168 resultptr = new wxVideoMode((wxVideoMode &)(result));
31169 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31170 }
31171 return resultobj;
31172 fail:
31173 return NULL;
31174 }
31175
31176
31177 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31178 PyObject *resultobj;
31179 wxDisplay *arg1 = (wxDisplay *) 0 ;
31180 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31181 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31182 bool result;
31183 PyObject * obj0 = 0 ;
31184 PyObject * obj1 = 0 ;
31185 char *kwnames[] = {
31186 (char *) "self",(char *) "mode", NULL
31187 };
31188
31189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31191 if (SWIG_arg_fail(1)) SWIG_fail;
31192 if (obj1) {
31193 {
31194 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31195 if (SWIG_arg_fail(2)) SWIG_fail;
31196 if (arg2 == NULL) {
31197 SWIG_null_ref("wxVideoMode");
31198 }
31199 if (SWIG_arg_fail(2)) SWIG_fail;
31200 }
31201 }
31202 {
31203 PyThreadState* __tstate = wxPyBeginAllowThreads();
31204 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31205
31206 wxPyEndAllowThreads(__tstate);
31207 if (PyErr_Occurred()) SWIG_fail;
31208 }
31209 {
31210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31211 }
31212 return resultobj;
31213 fail:
31214 return NULL;
31215 }
31216
31217
31218 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31219 PyObject *resultobj;
31220 wxDisplay *arg1 = (wxDisplay *) 0 ;
31221 PyObject * obj0 = 0 ;
31222 char *kwnames[] = {
31223 (char *) "self", NULL
31224 };
31225
31226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31228 if (SWIG_arg_fail(1)) SWIG_fail;
31229 {
31230 PyThreadState* __tstate = wxPyBeginAllowThreads();
31231 (arg1)->ResetMode();
31232
31233 wxPyEndAllowThreads(__tstate);
31234 if (PyErr_Occurred()) SWIG_fail;
31235 }
31236 Py_INCREF(Py_None); resultobj = Py_None;
31237 return resultobj;
31238 fail:
31239 return NULL;
31240 }
31241
31242
31243 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31244 PyObject *obj;
31245 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31246 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31247 Py_INCREF(obj);
31248 return Py_BuildValue((char *)"");
31249 }
31250 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31251 PyObject *resultobj;
31252 wxStandardPaths *result;
31253 char *kwnames[] = {
31254 NULL
31255 };
31256
31257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31258 {
31259 PyThreadState* __tstate = wxPyBeginAllowThreads();
31260 result = (wxStandardPaths *)StandardPaths_Get();
31261
31262 wxPyEndAllowThreads(__tstate);
31263 if (PyErr_Occurred()) SWIG_fail;
31264 }
31265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31266 return resultobj;
31267 fail:
31268 return NULL;
31269 }
31270
31271
31272 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31273 PyObject *resultobj;
31274 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31275 wxString result;
31276 PyObject * obj0 = 0 ;
31277 char *kwnames[] = {
31278 (char *) "self", NULL
31279 };
31280
31281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31283 if (SWIG_arg_fail(1)) SWIG_fail;
31284 {
31285 PyThreadState* __tstate = wxPyBeginAllowThreads();
31286 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31287
31288 wxPyEndAllowThreads(__tstate);
31289 if (PyErr_Occurred()) SWIG_fail;
31290 }
31291 {
31292 #if wxUSE_UNICODE
31293 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31294 #else
31295 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31296 #endif
31297 }
31298 return resultobj;
31299 fail:
31300 return NULL;
31301 }
31302
31303
31304 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31305 PyObject *resultobj;
31306 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31307 wxString result;
31308 PyObject * obj0 = 0 ;
31309 char *kwnames[] = {
31310 (char *) "self", NULL
31311 };
31312
31313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31315 if (SWIG_arg_fail(1)) SWIG_fail;
31316 {
31317 PyThreadState* __tstate = wxPyBeginAllowThreads();
31318 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31319
31320 wxPyEndAllowThreads(__tstate);
31321 if (PyErr_Occurred()) SWIG_fail;
31322 }
31323 {
31324 #if wxUSE_UNICODE
31325 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31326 #else
31327 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31328 #endif
31329 }
31330 return resultobj;
31331 fail:
31332 return NULL;
31333 }
31334
31335
31336 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31337 PyObject *resultobj;
31338 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31339 wxString result;
31340 PyObject * obj0 = 0 ;
31341 char *kwnames[] = {
31342 (char *) "self", NULL
31343 };
31344
31345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31347 if (SWIG_arg_fail(1)) SWIG_fail;
31348 {
31349 PyThreadState* __tstate = wxPyBeginAllowThreads();
31350 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31351
31352 wxPyEndAllowThreads(__tstate);
31353 if (PyErr_Occurred()) SWIG_fail;
31354 }
31355 {
31356 #if wxUSE_UNICODE
31357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31358 #else
31359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31360 #endif
31361 }
31362 return resultobj;
31363 fail:
31364 return NULL;
31365 }
31366
31367
31368 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31369 PyObject *resultobj;
31370 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31371 wxString result;
31372 PyObject * obj0 = 0 ;
31373 char *kwnames[] = {
31374 (char *) "self", NULL
31375 };
31376
31377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31379 if (SWIG_arg_fail(1)) SWIG_fail;
31380 {
31381 PyThreadState* __tstate = wxPyBeginAllowThreads();
31382 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31383
31384 wxPyEndAllowThreads(__tstate);
31385 if (PyErr_Occurred()) SWIG_fail;
31386 }
31387 {
31388 #if wxUSE_UNICODE
31389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31390 #else
31391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31392 #endif
31393 }
31394 return resultobj;
31395 fail:
31396 return NULL;
31397 }
31398
31399
31400 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31401 PyObject *resultobj;
31402 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31403 wxString result;
31404 PyObject * obj0 = 0 ;
31405 char *kwnames[] = {
31406 (char *) "self", NULL
31407 };
31408
31409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31411 if (SWIG_arg_fail(1)) SWIG_fail;
31412 {
31413 PyThreadState* __tstate = wxPyBeginAllowThreads();
31414 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31415
31416 wxPyEndAllowThreads(__tstate);
31417 if (PyErr_Occurred()) SWIG_fail;
31418 }
31419 {
31420 #if wxUSE_UNICODE
31421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31422 #else
31423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31424 #endif
31425 }
31426 return resultobj;
31427 fail:
31428 return NULL;
31429 }
31430
31431
31432 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31433 PyObject *resultobj;
31434 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31435 wxString result;
31436 PyObject * obj0 = 0 ;
31437 char *kwnames[] = {
31438 (char *) "self", NULL
31439 };
31440
31441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31443 if (SWIG_arg_fail(1)) SWIG_fail;
31444 {
31445 PyThreadState* __tstate = wxPyBeginAllowThreads();
31446 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31447
31448 wxPyEndAllowThreads(__tstate);
31449 if (PyErr_Occurred()) SWIG_fail;
31450 }
31451 {
31452 #if wxUSE_UNICODE
31453 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31454 #else
31455 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31456 #endif
31457 }
31458 return resultobj;
31459 fail:
31460 return NULL;
31461 }
31462
31463
31464 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31465 PyObject *resultobj;
31466 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31467 wxString result;
31468 PyObject * obj0 = 0 ;
31469 char *kwnames[] = {
31470 (char *) "self", NULL
31471 };
31472
31473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31475 if (SWIG_arg_fail(1)) SWIG_fail;
31476 {
31477 PyThreadState* __tstate = wxPyBeginAllowThreads();
31478 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31479
31480 wxPyEndAllowThreads(__tstate);
31481 if (PyErr_Occurred()) SWIG_fail;
31482 }
31483 {
31484 #if wxUSE_UNICODE
31485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31486 #else
31487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31488 #endif
31489 }
31490 return resultobj;
31491 fail:
31492 return NULL;
31493 }
31494
31495
31496 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31497 PyObject *resultobj;
31498 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31499 wxString *arg2 = 0 ;
31500 bool temp2 = false ;
31501 PyObject * obj0 = 0 ;
31502 PyObject * obj1 = 0 ;
31503 char *kwnames[] = {
31504 (char *) "self",(char *) "prefix", NULL
31505 };
31506
31507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31509 if (SWIG_arg_fail(1)) SWIG_fail;
31510 {
31511 arg2 = wxString_in_helper(obj1);
31512 if (arg2 == NULL) SWIG_fail;
31513 temp2 = true;
31514 }
31515 {
31516 PyThreadState* __tstate = wxPyBeginAllowThreads();
31517 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31518
31519 wxPyEndAllowThreads(__tstate);
31520 if (PyErr_Occurred()) SWIG_fail;
31521 }
31522 Py_INCREF(Py_None); resultobj = Py_None;
31523 {
31524 if (temp2)
31525 delete arg2;
31526 }
31527 return resultobj;
31528 fail:
31529 {
31530 if (temp2)
31531 delete arg2;
31532 }
31533 return NULL;
31534 }
31535
31536
31537 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31538 PyObject *resultobj;
31539 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31540 wxString result;
31541 PyObject * obj0 = 0 ;
31542 char *kwnames[] = {
31543 (char *) "self", NULL
31544 };
31545
31546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31548 if (SWIG_arg_fail(1)) SWIG_fail;
31549 {
31550 PyThreadState* __tstate = wxPyBeginAllowThreads();
31551 result = wxStandardPaths_GetInstallPrefix(arg1);
31552
31553 wxPyEndAllowThreads(__tstate);
31554 if (PyErr_Occurred()) SWIG_fail;
31555 }
31556 {
31557 #if wxUSE_UNICODE
31558 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31559 #else
31560 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31561 #endif
31562 }
31563 return resultobj;
31564 fail:
31565 return NULL;
31566 }
31567
31568
31569 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31570 PyObject *obj;
31571 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31572 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31573 Py_INCREF(obj);
31574 return Py_BuildValue((char *)"");
31575 }
31576 static PyMethodDef SwigMethods[] = {
31577 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31584 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31592 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31658 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31666 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31684 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31687 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31690 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31693 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31699 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31713 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31719 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31725 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31728 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31742 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31745 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31746 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31749 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31776 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31778 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31780 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31782 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31789 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31795 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31809 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31813 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31816 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31833 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31841 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31888 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31906 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31916 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31932 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31948 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31962 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31972 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
32015 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
32018 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
32021 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
32025 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32118 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32119 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32120 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32121 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32138 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32183 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32217 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32225 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32226 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32231 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32240 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32247 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32250 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32253 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32258 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32261 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32265 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32268 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32272 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32273 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32277 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32279 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32280 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32281 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32285 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32286 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32290 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32292 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32293 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32294 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32295 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32296 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32297 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32298 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32299 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32300 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32301 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32302 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32303 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32304 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32305 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32306 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32307 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32308 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32309 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32310 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32311 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32312 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32313 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32314 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32315 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32316 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32317 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32318 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32319 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32320 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32321 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32322 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32323 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32324 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32325 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32326 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32327 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32328 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32329 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32330 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32331 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32332 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32333 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32334 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32335 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32336 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32337 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32338 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32339 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32340 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32341 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32342 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32343 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32344 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32345 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32346 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32347 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32348 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32349 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32350 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32351 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32352 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32353 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32354 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32355 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32356 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32357 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32358 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32359 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32360 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32361 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32362 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32363 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32364 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32365 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32366 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32367 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32368 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32369 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32370 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32371 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32372 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32373 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32374 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32375 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32376 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32377 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32378 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32379 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32380 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32381 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32382 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32383 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32384 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32385 { NULL, NULL, 0, NULL }
32386 };
32387
32388
32389 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32390
32391 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32392 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32393 }
32394 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32395 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32396 }
32397 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32398 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32399 }
32400 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32401 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32402 }
32403 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32404 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32405 }
32406 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32407 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32408 }
32409 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32410 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32411 }
32412 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32413 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32414 }
32415 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32416 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32417 }
32418 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32419 return (void *)((wxEvent *) ((wxPyEvent *) x));
32420 }
32421 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32422 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32423 }
32424 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32425 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32426 }
32427 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32428 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32429 }
32430 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32431 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32432 }
32433 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32434 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32435 }
32436 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32437 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32438 }
32439 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32440 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32441 }
32442 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32443 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32444 }
32445 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32446 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32447 }
32448 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32449 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32450 }
32451 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32452 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32453 }
32454 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32455 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32456 }
32457 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32458 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32459 }
32460 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32461 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32462 }
32463 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32464 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32465 }
32466 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32467 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32468 }
32469 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32470 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32471 }
32472 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32473 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32474 }
32475 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32476 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32477 }
32478 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32479 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32480 }
32481 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32482 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32483 }
32484 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32485 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32486 }
32487 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32488 return (void *)((wxEvent *) ((wxShowEvent *) x));
32489 }
32490 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32491 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32492 }
32493 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32494 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32495 }
32496 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32497 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32498 }
32499 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32500 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32501 }
32502 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32503 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32504 }
32505 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32506 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32507 }
32508 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32509 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32510 }
32511 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32512 return (void *)((wxConfigBase *) ((wxConfig *) x));
32513 }
32514 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32515 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32516 }
32517 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32518 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32519 }
32520 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32521 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32522 }
32523 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32524 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32525 }
32526 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32527 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32528 }
32529 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32530 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32531 }
32532 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32533 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32534 }
32535 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32536 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32537 }
32538 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32539 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32540 }
32541 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32542 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32543 }
32544 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32545 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32546 }
32547 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32548 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32549 }
32550 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32551 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32552 }
32553 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32554 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32555 }
32556 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32557 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32558 }
32559 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32560 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32561 }
32562 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32563 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32564 }
32565 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32566 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32567 }
32568 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32569 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32570 }
32571 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32572 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32573 }
32574 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32575 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32576 }
32577 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32578 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32579 }
32580 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32581 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32582 }
32583 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32584 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32585 }
32586 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32587 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32588 }
32589 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32590 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32591 }
32592 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32593 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32594 }
32595 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32596 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32597 }
32598 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32599 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32600 }
32601 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32602 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32603 }
32604 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32605 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32606 }
32607 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32608 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32609 }
32610 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32611 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32612 }
32613 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32614 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32615 }
32616 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32617 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32618 }
32619 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32620 return (void *)((wxObject *) ((wxSizerItem *) x));
32621 }
32622 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32623 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32624 }
32625 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32626 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32627 }
32628 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32629 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32630 }
32631 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32632 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32633 }
32634 static void *_p_wxSizerTo_p_wxObject(void *x) {
32635 return (void *)((wxObject *) ((wxSizer *) x));
32636 }
32637 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32638 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32639 }
32640 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32641 return (void *)((wxObject *) ((wxFileHistory *) x));
32642 }
32643 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32644 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32645 }
32646 static void *_p_wxEventTo_p_wxObject(void *x) {
32647 return (void *)((wxObject *) ((wxEvent *) x));
32648 }
32649 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32650 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32651 }
32652 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32653 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32654 }
32655 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32656 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32657 }
32658 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32659 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32660 }
32661 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32662 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32663 }
32664 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32665 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32666 }
32667 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32668 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32669 }
32670 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32671 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32672 }
32673 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32674 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32675 }
32676 static void *_p_wxControlTo_p_wxObject(void *x) {
32677 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32678 }
32679 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32680 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32681 }
32682 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32683 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32684 }
32685 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32686 return (void *)((wxObject *) ((wxFSFile *) x));
32687 }
32688 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32689 return (void *)((wxObject *) ((wxClipboard *) x));
32690 }
32691 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32692 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32693 }
32694 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32695 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32696 }
32697 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32698 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32699 }
32700 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32701 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32702 }
32703 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32704 return (void *)((wxObject *) ((wxToolTip *) x));
32705 }
32706 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32707 return (void *)((wxObject *) ((wxMenuItem *) x));
32708 }
32709 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32710 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32711 }
32712 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32713 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32714 }
32715 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32716 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32717 }
32718 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32719 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32720 }
32721 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32722 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32723 }
32724 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32725 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32726 }
32727 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32728 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32729 }
32730 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32731 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32732 }
32733 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32734 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32735 }
32736 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32737 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32738 }
32739 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32740 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32741 }
32742 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32743 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32744 }
32745 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32746 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32747 }
32748 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32749 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32750 }
32751 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32752 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32753 }
32754 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32755 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32756 }
32757 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32758 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32759 }
32760 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32761 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32762 }
32763 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32764 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32765 }
32766 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32767 return (void *)((wxObject *) ((wxImageHandler *) x));
32768 }
32769 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32770 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32771 }
32772 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32773 return (void *)((wxObject *) ((wxEvtHandler *) x));
32774 }
32775 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32776 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32777 }
32778 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32779 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32780 }
32781 static void *_p_wxImageTo_p_wxObject(void *x) {
32782 return (void *)((wxObject *) ((wxImage *) x));
32783 }
32784 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32785 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32786 }
32787 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32788 return (void *)((wxObject *) ((wxSystemOptions *) x));
32789 }
32790 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32791 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32792 }
32793 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32794 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32795 }
32796 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32797 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32798 }
32799 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32800 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32801 }
32802 static void *_p_wxWindowTo_p_wxObject(void *x) {
32803 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32804 }
32805 static void *_p_wxMenuTo_p_wxObject(void *x) {
32806 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32807 }
32808 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32809 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32810 }
32811 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32812 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32813 }
32814 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32815 return (void *)((wxObject *) ((wxFileSystem *) x));
32816 }
32817 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32818 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32819 }
32820 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32821 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32822 }
32823 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32824 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32825 }
32826 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32827 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32828 }
32829 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32830 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32831 }
32832 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32833 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32834 }
32835 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32836 return (void *)((wxObject *) ((wxBusyInfo *) x));
32837 }
32838 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32839 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32840 }
32841 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32842 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32843 }
32844 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32845 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32846 }
32847 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32848 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32849 }
32850 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32851 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32852 }
32853 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32854 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32855 }
32856 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32857 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32858 }
32859 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32860 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32861 }
32862 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32863 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32864 }
32865 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32866 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32867 }
32868 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32869 return (void *)((wxLog *) ((wxLogStderr *) x));
32870 }
32871 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32872 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32873 }
32874 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32875 return (void *)((wxLog *) ((wxLogWindow *) x));
32876 }
32877 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32878 return (void *)((wxLog *) ((wxLogChain *) x));
32879 }
32880 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32881 return (void *)((wxLog *) ((wxLogGui *) x));
32882 }
32883 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32884 return (void *)((wxLog *) ((wxPyLog *) x));
32885 }
32886 static void *_p_wxControlTo_p_wxWindow(void *x) {
32887 return (void *)((wxWindow *) ((wxControl *) x));
32888 }
32889 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32890 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32891 }
32892 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32893 return (void *)((wxWindow *) ((wxMenuBar *) x));
32894 }
32895 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32896 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32897 }
32898 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32899 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32900 }
32901 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}};
32902 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}};
32903 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}};
32904 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}};
32905 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}};
32906 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}};
32907 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}};
32908 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}};
32909 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}};
32910 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}};
32911 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}};
32912 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}};
32913 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}};
32914 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}};
32915 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}};
32916 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}};
32917 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}};
32918 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}};
32919 static swig_type_info _swigt__p_void[] = {{"_p_void", 0, "void *", 0, 0, 0, 0},{"_p_void", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32920 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}};
32921 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}};
32922 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}};
32923 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}};
32924 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}};
32925 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}};
32926 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}};
32927 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}};
32928 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}};
32929 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}};
32930 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}};
32931 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}};
32932 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}};
32933 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}};
32934 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}};
32935 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}};
32936 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}};
32937 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}};
32938 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}};
32939 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}};
32940 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}};
32941 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}};
32942 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}};
32943 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}};
32944 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}};
32945 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}};
32946 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}};
32947 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}};
32948 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}};
32949 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}};
32950 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}};
32951 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}};
32952 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}};
32953 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}};
32954 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}};
32955 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}};
32956 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}};
32957 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}};
32958 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}};
32959 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}};
32960 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}};
32961 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}};
32962 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}};
32963 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}};
32964 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}};
32965 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}};
32966 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}};
32967 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}};
32968 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}};
32969 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}};
32970 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}};
32971 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}};
32972 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}};
32973 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}};
32974 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}};
32975 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}};
32976 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}};
32977 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}};
32978 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}};
32979 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}};
32980 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}};
32981 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}};
32982 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}};
32983 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}};
32984 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}};
32985 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}};
32986 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}};
32987 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}};
32988 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}};
32989 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}};
32990 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}};
32991 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}};
32992 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}};
32993 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}};
32994 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}};
32995 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}};
32996 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}};
32997 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}};
32998 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}};
32999
33000 static swig_type_info *swig_types_initial[] = {
33001 _swigt__p_wxLogChain,
33002 _swigt__p_wxMutexGuiLocker,
33003 _swigt__p_wxMetafile,
33004 _swigt__p_wxFileHistory,
33005 _swigt__p_wxLog,
33006 _swigt__p_wxMenu,
33007 _swigt__p_wxEvent,
33008 _swigt__p_wxDateTime__TimeZone,
33009 _swigt__p_wxConfigBase,
33010 _swigt__p_wxDisplay,
33011 _swigt__p_wxFileType,
33012 _swigt__p_wxLogGui,
33013 _swigt__p_wxFont,
33014 _swigt__p_wxDataFormat,
33015 _swigt__p_wxTimerEvent,
33016 _swigt__p_wxCaret,
33017 _swigt__ptrdiff_t,
33018 _swigt__std__ptrdiff_t,
33019 _swigt__p_void,
33020 _swigt__p_int,
33021 _swigt__p_wxSize,
33022 _swigt__p_wxClipboard,
33023 _swigt__p_wxStopWatch,
33024 _swigt__p_wxDC,
33025 _swigt__p_wxClipboardLocker,
33026 _swigt__p_wxIcon,
33027 _swigt__p_wxLogStderr,
33028 _swigt__p_wxLogTextCtrl,
33029 _swigt__p_wxTextCtrl,
33030 _swigt__p_wxBusyCursor,
33031 _swigt__p_wxBitmapDataObject,
33032 _swigt__p_wxTextDataObject,
33033 _swigt__p_wxDataObject,
33034 _swigt__p_wxPyTextDataObject,
33035 _swigt__p_wxPyBitmapDataObject,
33036 _swigt__p_wxFileDataObject,
33037 _swigt__p_wxCustomDataObject,
33038 _swigt__p_wxURLDataObject,
33039 _swigt__p_wxMetafileDataObject,
33040 _swigt__p_wxSound,
33041 _swigt__p_wxTimerRunner,
33042 _swigt__p_wxLogWindow,
33043 _swigt__p_wxTimeSpan,
33044 _swigt__p_wxArrayString,
33045 _swigt__p_wxWindowDisabler,
33046 _swigt__p_form_ops_t,
33047 _swigt__p_wxToolTip,
33048 _swigt__p_wxDataObjectComposite,
33049 _swigt__p_wxSystemSettings,
33050 _swigt__p_wxFileConfig,
33051 _swigt__p_wxVideoMode,
33052 _swigt__p_wxDataObjectSimple,
33053 _swigt__p_wxPyDataObjectSimple,
33054 _swigt__p_wxDuplexMode,
33055 _swigt__p_wxEvtHandler,
33056 _swigt__p_wxRect,
33057 _swigt__p_char,
33058 _swigt__p_wxSingleInstanceChecker,
33059 _swigt__p_wxStandardPaths,
33060 _swigt__p_wxFileTypeInfo,
33061 _swigt__p_wxFrame,
33062 _swigt__p_wxTimer,
33063 _swigt__p_wxPaperSize,
33064 _swigt__p_wxMimeTypesManager,
33065 _swigt__p_wxPyArtProvider,
33066 _swigt__p_wxPyTipProvider,
33067 _swigt__p_wxTipProvider,
33068 _swigt__p_wxJoystick,
33069 _swigt__p_wxSystemOptions,
33070 _swigt__p_wxPoint,
33071 _swigt__p_wxJoystickEvent,
33072 _swigt__p_wxCursor,
33073 _swigt__p_wxObject,
33074 _swigt__p_wxOutputStream,
33075 _swigt__p_wxDateTime,
33076 _swigt__p_wxPyDropSource,
33077 _swigt__p_unsigned_long,
33078 _swigt__p_wxKillError,
33079 _swigt__p_wxWindow,
33080 _swigt__p_wxString,
33081 _swigt__p_wxPyProcess,
33082 _swigt__p_wxBitmap,
33083 _swigt__unsigned_int,
33084 _swigt__p_unsigned_int,
33085 _swigt__p_wxConfig,
33086 _swigt__p_unsigned_char,
33087 _swigt__p_wxChar,
33088 _swigt__p_wxBusyInfo,
33089 _swigt__p_wxPyDropTarget,
33090 _swigt__p_wxPyTextDropTarget,
33091 _swigt__p_wxPyFileDropTarget,
33092 _swigt__p_wxProcessEvent,
33093 _swigt__p_wxPyLog,
33094 _swigt__p_wxLogNull,
33095 _swigt__p_wxColour,
33096 _swigt__p_wxPyTimer,
33097 _swigt__p_wxConfigPathChanger,
33098 _swigt__p_wxDateSpan,
33099 0
33100 };
33101
33102
33103 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33104
33105 static swig_const_info swig_const_table[] = {
33106 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33107 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33108 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33109 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33110 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33111 {0, 0, 0, 0.0, 0, 0}};
33112
33113 #ifdef __cplusplus
33114 }
33115 #endif
33116
33117
33118 #ifdef __cplusplus
33119 extern "C" {
33120 #endif
33121
33122 /* Python-specific SWIG API */
33123 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33124 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33125 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33126
33127 /* -----------------------------------------------------------------------------
33128 * global variable support code.
33129 * ----------------------------------------------------------------------------- */
33130
33131 typedef struct swig_globalvar {
33132 char *name; /* Name of global variable */
33133 PyObject *(*get_attr)(); /* Return the current value */
33134 int (*set_attr)(PyObject *); /* Set the value */
33135 struct swig_globalvar *next;
33136 } swig_globalvar;
33137
33138 typedef struct swig_varlinkobject {
33139 PyObject_HEAD
33140 swig_globalvar *vars;
33141 } swig_varlinkobject;
33142
33143 static PyObject *
33144 swig_varlink_repr(swig_varlinkobject *v) {
33145 v = v;
33146 return PyString_FromString("<Swig global variables>");
33147 }
33148
33149 static int
33150 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33151 swig_globalvar *var;
33152 flags = flags;
33153 fprintf(fp,"Swig global variables { ");
33154 for (var = v->vars; var; var=var->next) {
33155 fprintf(fp,"%s", var->name);
33156 if (var->next) fprintf(fp,", ");
33157 }
33158 fprintf(fp," }\n");
33159 return 0;
33160 }
33161
33162 static PyObject *
33163 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33164 swig_globalvar *var = v->vars;
33165 while (var) {
33166 if (strcmp(var->name,n) == 0) {
33167 return (*var->get_attr)();
33168 }
33169 var = var->next;
33170 }
33171 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33172 return NULL;
33173 }
33174
33175 static int
33176 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33177 swig_globalvar *var = v->vars;
33178 while (var) {
33179 if (strcmp(var->name,n) == 0) {
33180 return (*var->set_attr)(p);
33181 }
33182 var = var->next;
33183 }
33184 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33185 return 1;
33186 }
33187
33188 static PyTypeObject varlinktype = {
33189 PyObject_HEAD_INIT(0)
33190 0, /* Number of items in variable part (ob_size) */
33191 (char *)"swigvarlink", /* Type name (tp_name) */
33192 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33193 0, /* Itemsize (tp_itemsize) */
33194 0, /* Deallocator (tp_dealloc) */
33195 (printfunc) swig_varlink_print, /* Print (tp_print) */
33196 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33197 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33198 0, /* tp_compare */
33199 (reprfunc) swig_varlink_repr, /* tp_repr */
33200 0, /* tp_as_number */
33201 0, /* tp_as_sequence */
33202 0, /* tp_as_mapping */
33203 0, /* tp_hash */
33204 0, /* tp_call */
33205 0, /* tp_str */
33206 0, /* tp_getattro */
33207 0, /* tp_setattro */
33208 0, /* tp_as_buffer */
33209 0, /* tp_flags */
33210 0, /* tp_doc */
33211 #if PY_VERSION_HEX >= 0x02000000
33212 0, /* tp_traverse */
33213 0, /* tp_clear */
33214 #endif
33215 #if PY_VERSION_HEX >= 0x02010000
33216 0, /* tp_richcompare */
33217 0, /* tp_weaklistoffset */
33218 #endif
33219 #if PY_VERSION_HEX >= 0x02020000
33220 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33221 #endif
33222 #if PY_VERSION_HEX >= 0x02030000
33223 0, /* tp_del */
33224 #endif
33225 #ifdef COUNT_ALLOCS
33226 0,0,0,0 /* tp_alloc -> tp_next */
33227 #endif
33228 };
33229
33230 /* Create a variable linking object for use later */
33231 static PyObject *
33232 SWIG_Python_newvarlink(void) {
33233 swig_varlinkobject *result = 0;
33234 result = PyMem_NEW(swig_varlinkobject,1);
33235 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33236 result->ob_type = &varlinktype;
33237 result->vars = 0;
33238 result->ob_refcnt = 0;
33239 Py_XINCREF((PyObject *) result);
33240 return ((PyObject*) result);
33241 }
33242
33243 static void
33244 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33245 swig_varlinkobject *v;
33246 swig_globalvar *gv;
33247 v= (swig_varlinkobject *) p;
33248 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33249 gv->name = (char *) malloc(strlen(name)+1);
33250 strcpy(gv->name,name);
33251 gv->get_attr = get_attr;
33252 gv->set_attr = set_attr;
33253 gv->next = v->vars;
33254 v->vars = gv;
33255 }
33256
33257 /* -----------------------------------------------------------------------------
33258 * constants/methods manipulation
33259 * ----------------------------------------------------------------------------- */
33260
33261 /* Install Constants */
33262 static void
33263 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33264 PyObject *obj = 0;
33265 size_t i;
33266 for (i = 0; constants[i].type; i++) {
33267 switch(constants[i].type) {
33268 case SWIG_PY_INT:
33269 obj = PyInt_FromLong(constants[i].lvalue);
33270 break;
33271 case SWIG_PY_FLOAT:
33272 obj = PyFloat_FromDouble(constants[i].dvalue);
33273 break;
33274 case SWIG_PY_STRING:
33275 if (constants[i].pvalue) {
33276 obj = PyString_FromString((char *) constants[i].pvalue);
33277 } else {
33278 Py_INCREF(Py_None);
33279 obj = Py_None;
33280 }
33281 break;
33282 case SWIG_PY_POINTER:
33283 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33284 break;
33285 case SWIG_PY_BINARY:
33286 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33287 break;
33288 default:
33289 obj = 0;
33290 break;
33291 }
33292 if (obj) {
33293 PyDict_SetItemString(d,constants[i].name,obj);
33294 Py_DECREF(obj);
33295 }
33296 }
33297 }
33298
33299 /* -----------------------------------------------------------------------------*/
33300 /* Fix SwigMethods to carry the callback ptrs when needed */
33301 /* -----------------------------------------------------------------------------*/
33302
33303 static void
33304 SWIG_Python_FixMethods(PyMethodDef *methods,
33305 swig_const_info *const_table,
33306 swig_type_info **types,
33307 swig_type_info **types_initial) {
33308 size_t i;
33309 for (i = 0; methods[i].ml_name; ++i) {
33310 char *c = methods[i].ml_doc;
33311 if (c && (c = strstr(c, "swig_ptr: "))) {
33312 int j;
33313 swig_const_info *ci = 0;
33314 char *name = c + 10;
33315 for (j = 0; const_table[j].type; j++) {
33316 if (strncmp(const_table[j].name, name,
33317 strlen(const_table[j].name)) == 0) {
33318 ci = &(const_table[j]);
33319 break;
33320 }
33321 }
33322 if (ci) {
33323 size_t shift = (ci->ptype) - types;
33324 swig_type_info *ty = types_initial[shift];
33325 size_t ldoc = (c - methods[i].ml_doc);
33326 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33327 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33328 char *buff = ndoc;
33329 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33330 strncpy(buff, methods[i].ml_doc, ldoc);
33331 buff += ldoc;
33332 strncpy(buff, "swig_ptr: ", 10);
33333 buff += 10;
33334 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33335 methods[i].ml_doc = ndoc;
33336 }
33337 }
33338 }
33339 }
33340
33341 /* -----------------------------------------------------------------------------*
33342 * Initialize type list
33343 * -----------------------------------------------------------------------------*/
33344
33345 #if PY_MAJOR_VERSION < 2
33346 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33347 is copied out of Python/modsupport.c in python version 2.3.4 */
33348 static int
33349 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33350 {
33351 PyObject *dict;
33352 if (!PyModule_Check(m)) {
33353 PyErr_SetString(PyExc_TypeError,
33354 "PyModule_AddObject() needs module as first arg");
33355 return -1;
33356 }
33357 if (!o) {
33358 PyErr_SetString(PyExc_TypeError,
33359 "PyModule_AddObject() needs non-NULL value");
33360 return -1;
33361 }
33362
33363 dict = PyModule_GetDict(m);
33364 if (dict == NULL) {
33365 /* Internal error -- modules must have a dict! */
33366 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33367 PyModule_GetName(m));
33368 return -1;
33369 }
33370 if (PyDict_SetItemString(dict, name, o))
33371 return -1;
33372 Py_DECREF(o);
33373 return 0;
33374 }
33375 #endif
33376
33377 static swig_type_info **
33378 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33379 static PyMethodDef swig_empty_runtime_method_table[] = {
33380 {
33381 NULL, NULL, 0, NULL
33382 }
33383 };/* Sentinel */
33384
33385 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33386 swig_empty_runtime_method_table);
33387 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33388 if (pointer && module) {
33389 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33390 }
33391 return type_list_handle;
33392 }
33393
33394 static swig_type_info **
33395 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33396 swig_type_info **type_pointer;
33397
33398 /* first check if module already created */
33399 type_pointer = SWIG_Python_GetTypeListHandle();
33400 if (type_pointer) {
33401 return type_pointer;
33402 } else {
33403 /* create a new module and variable */
33404 return SWIG_Python_SetTypeListHandle(type_list_handle);
33405 }
33406 }
33407
33408 #ifdef __cplusplus
33409 }
33410 #endif
33411
33412 /* -----------------------------------------------------------------------------*
33413 * Partial Init method
33414 * -----------------------------------------------------------------------------*/
33415
33416 #ifdef SWIG_LINK_RUNTIME
33417 #ifdef __cplusplus
33418 extern "C"
33419 #endif
33420 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33421 #endif
33422
33423 #ifdef __cplusplus
33424 extern "C"
33425 #endif
33426 SWIGEXPORT(void) SWIG_init(void) {
33427 static PyObject *SWIG_globals = 0;
33428 static int typeinit = 0;
33429 PyObject *m, *d;
33430 int i;
33431 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33432
33433 /* Fix SwigMethods to carry the callback ptrs when needed */
33434 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33435
33436 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33437 d = PyModule_GetDict(m);
33438
33439 if (!typeinit) {
33440 #ifdef SWIG_LINK_RUNTIME
33441 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33442 #else
33443 # ifndef SWIG_STATIC_RUNTIME
33444 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33445 # endif
33446 #endif
33447 for (i = 0; swig_types_initial[i]; i++) {
33448 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33449 }
33450 typeinit = 1;
33451 }
33452 SWIG_InstallConstants(d,swig_const_table);
33453
33454 {
33455 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33456 }
33457 {
33458 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33459 }
33460 {
33461 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33462 }
33463 {
33464 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33465 }
33466 {
33467 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33468 }
33469 {
33470 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33471 }
33472 {
33473 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33474 }
33475 {
33476 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33477 }
33478 {
33479 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33480 }
33481 {
33482 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33483 }
33484 {
33485 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33486 }
33487 {
33488 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33489 }
33490 {
33491 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33492 }
33493 {
33494 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33495 }
33496 {
33497 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33498 }
33499 {
33500 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33501 }
33502 {
33503 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33504 }
33505 {
33506 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33507 }
33508 {
33509 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33510 }
33511 {
33512 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33513 }
33514 {
33515 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33516 }
33517 {
33518 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33519 }
33520 {
33521 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33522 }
33523 {
33524 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33525 }
33526 {
33527 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33528 }
33529 {
33530 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33531 }
33532 {
33533 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33534 }
33535 {
33536 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33537 }
33538 {
33539 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33540 }
33541 {
33542 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33543 }
33544 {
33545 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33546 }
33547 {
33548 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33549 }
33550 {
33551 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33552 }
33553 {
33554 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33555 }
33556 {
33557 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33558 }
33559 {
33560 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33561 }
33562 {
33563 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33564 }
33565 {
33566 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33567 }
33568 {
33569 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33570 }
33571 {
33572 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33573 }
33574 {
33575 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33576 }
33577 {
33578 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33579 }
33580 {
33581 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33582 }
33583 {
33584 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33585 }
33586 {
33587 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33588 }
33589 {
33590 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33591 }
33592 {
33593 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33594 }
33595 {
33596 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33600 }
33601 {
33602 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33603 }
33604 {
33605 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33606 }
33607 {
33608 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33609 }
33610 {
33611 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33612 }
33613 {
33614 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33615 }
33616 {
33617 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33618 }
33619 {
33620 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33621 }
33622 {
33623 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33624 }
33625 {
33626 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33627 }
33628 {
33629 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33630 }
33631 {
33632 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33633 }
33634 {
33635 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33636 }
33637 {
33638 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33639 }
33640 {
33641 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33642 }
33643 {
33644 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33645 }
33646 {
33647 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33648 }
33649 {
33650 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33651 }
33652 {
33653 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33654 }
33655 {
33656 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33657 }
33658 {
33659 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33660 }
33661 {
33662 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33663 }
33664 {
33665 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33666 }
33667 {
33668 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33669 }
33670 {
33671 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33672 }
33673 {
33674 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33675 }
33676 {
33677 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33678 }
33679 {
33680 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33681 }
33682 {
33683 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33684 }
33685 {
33686 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33687 }
33688 {
33689 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33690 }
33691 {
33692 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33693 }
33694 {
33695 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33696 }
33697 {
33698 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33699 }
33700 {
33701 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33702 }
33703 {
33704 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33705 }
33706 {
33707 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33708 }
33709 {
33710 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33711 }
33712 {
33713 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33714 }
33715 {
33716 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33717 }
33718 {
33719 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33720 }
33721 {
33722 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33723 }
33724 {
33725 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33726 }
33727 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33728 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33729 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33730 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33731 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33732 {
33733 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33734 }
33735 {
33736 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33737 }
33738 {
33739 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33740 }
33741 {
33742 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33743 }
33744 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33745
33746 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33747
33748 {
33749 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33750 }
33751 {
33752 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33753 }
33754 {
33755 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33756 }
33757 {
33758 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33759 }
33760 {
33761 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33762 }
33763 {
33764 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33765 }
33766 {
33767 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33768 }
33769 {
33770 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33771 }
33772 {
33773 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33774 }
33775 {
33776 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33777 }
33778 {
33779 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33780 }
33781 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33782 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33783 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33784 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33785 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33786 {
33787 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33872 }
33873 {
33874 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33875 }
33876 {
33877 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33878 }
33879 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33880 {
33881 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33882 }
33883 {
33884 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33885 }
33886 {
33887 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33888 }
33889 {
33890 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33891 }
33892 {
33893 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33894 }
33895
33896 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33897
33898 {
33899 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33900 }
33901 {
33902 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33909 }
33910 {
33911 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33918 }
33919 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33920 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33921 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33922 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33923 {
33924 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33925 }
33926 {
33927 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33928 }
33929 {
33930 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33931 }
33932 {
33933 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33934 }
33935 {
33936 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33937 }
33938 {
33939 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33940 }
33941 {
33942 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33943 }
33944 {
33945 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33946 }
33947 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33948 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33949 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33950 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33951 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33952 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33953 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33954 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33955 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33956 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33957 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33958 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33959 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33960 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33961 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33962 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33963 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33964 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33965 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33966 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33967 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33968 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33969 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33970 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33971 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33972 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33973 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33974 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33975 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33976 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33977 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33978 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33979 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33980 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33981 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33982 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33983 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33984 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33985 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33986 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33987 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33988 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33989 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33990 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33991 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33992 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33993 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33994 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33995 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33996 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33997 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33998 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW",_wrap_ART_NEW_get, _wrap_ART_NEW_set);
33999 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
34000 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
34001 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
34002 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
34003 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
34004
34005 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
34006
34007 {
34008 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
34009 }
34010 {
34011 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
34012 }
34013 {
34014 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
34015 }
34016 {
34017 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
34018 }
34019 {
34020 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
34021 }
34022 {
34023 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
34024 }
34025 {
34026 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
34027 }
34028 {
34029 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
34030 }
34031 {
34032 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
34033 }
34034 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
34035 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
34036 {
34037 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
34038 }
34039 {
34040 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
34041 }
34042 {
34043 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
34044 }
34045 {
34046 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
34047 }
34048 {
34049 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
34050 }
34051 {
34052 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
34053 }
34054 {
34055 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
34056 }
34057 {
34058 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
34059 }
34060 {
34061 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
34062 }
34063 {
34064 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
34065 }
34066 {
34067 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
34068 }
34069 {
34070 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
34071 }
34072 {
34073 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
34074 }
34075 {
34076 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
34077 }
34078 {
34079 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
34080 }
34081 {
34082 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
34083 }
34084 {
34085 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
34086 }
34087 {
34088 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
34089 }
34090 {
34091 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
34092 }
34093 {
34094 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
34095 }
34096 {
34097 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34098 }
34099 {
34100 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34101 }
34102 {
34103 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34104 }
34105 {
34106 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34107 }
34108 {
34109 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34110 }
34111 {
34112 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34113 }
34114 {
34115 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34116 }
34117 {
34118 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34119 }
34120 {
34121 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34122 }
34123 {
34124 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34125 }
34126 {
34127 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34128 }
34129 {
34130 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34131 }
34132 {
34133 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34134 }
34135 {
34136 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34137 }
34138 {
34139 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34140 }
34141 {
34142 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34143 }
34144 {
34145 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34146 }
34147 {
34148 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34149 }
34150 {
34151 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34152 }
34153 {
34154 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34155 }
34156 {
34157 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34158 }
34159 {
34160 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34161 }
34162 {
34163 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34164 }
34165 {
34166 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34167 }
34168 {
34169 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34170 }
34171 {
34172 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34173 }
34174 {
34175 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34176 }
34177 {
34178 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34179 }
34180 {
34181 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34182 }
34183 {
34184 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34185 }
34186 {
34187 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34188 }
34189 {
34190 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34191 }
34192 {
34193 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34194 }
34195 {
34196 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34197 }
34198 {
34199 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34200 }
34201 {
34202 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34203 }
34204 {
34205 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34206 }
34207 {
34208 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34209 }
34210 {
34211 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34212 }
34213 {
34214 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34215 }
34216 {
34217 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34218 }
34219 {
34220 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34221 }
34222 {
34223 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34224 }
34225 {
34226 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34227 }
34228 {
34229 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34230 }
34231 {
34232 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34233 }
34234 {
34235 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34236 }
34237 {
34238 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34239 }
34240 {
34241 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34242 }
34243 {
34244 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34245 }
34246 {
34247 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34248 }
34249 {
34250 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34251 }
34252 {
34253 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34254 }
34255 {
34256 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34257 }
34258 {
34259 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34260 }
34261 {
34262 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34263 }
34264 {
34265 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34266 }
34267 {
34268 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34269 }
34270 {
34271 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34272 }
34273 {
34274 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34275 }
34276 {
34277 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34278 }
34279 {
34280 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34281 }
34282 {
34283 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34284 }
34285 {
34286 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34287 }
34288 {
34289 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34290 }
34291 {
34292 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34293 }
34294 {
34295 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34296 }
34297 {
34298 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34299 }
34300 {
34301 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34302 }
34303 {
34304 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34305 }
34306 {
34307 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34308 }
34309 {
34310 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34311 }
34312 {
34313 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34314 }
34315 {
34316 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34317 }
34318 {
34319 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34320 }
34321 {
34322 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34323 }
34324 {
34325 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34326 }
34327 {
34328 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34329 }
34330 {
34331 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34332 }
34333 {
34334 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34335 }
34336 {
34337 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34338 }
34339 {
34340 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34341 }
34342 {
34343 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34344 }
34345 {
34346 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34347 }
34348 {
34349 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34350 }
34351 {
34352 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34353 }
34354 {
34355 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34356 }
34357 {
34358 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34359 }
34360 {
34361 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34362 }
34363 {
34364 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34365 }
34366 {
34367 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34368 }
34369 {
34370 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34371 }
34372 {
34373 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34374 }
34375 {
34376 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34377 }
34378 {
34379 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34380 }
34381 {
34382 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34383 }
34384 {
34385 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34386 }
34387 {
34388 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34389 }
34390 {
34391 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34392 }
34393 {
34394 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34395 }
34396 {
34397 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34398 }
34399 {
34400 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34401 }
34402 {
34403 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34404 }
34405 {
34406 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34407 }
34408 {
34409 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34410 }
34411 {
34412 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34413 }
34414 {
34415 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34416 }
34417 {
34418 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34419 }
34420 {
34421 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34422 }
34423 {
34424 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34425 }
34426 {
34427 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34428 }
34429 {
34430 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34431 }
34432 {
34433 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34434 }
34435 {
34436 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34437 }
34438 {
34439 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34440 }
34441 {
34442 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34443 }
34444 {
34445 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34446 }
34447 {
34448 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34449 }
34450 {
34451 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34452 }
34453 {
34454 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34455 }
34456 {
34457 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34458 }
34459 {
34460 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34461 }
34462 {
34463 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34464 }
34465 {
34466 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34467 }
34468 {
34469 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34470 }
34471 {
34472 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34473 }
34474 {
34475 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34476 }
34477 {
34478 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34479 }
34480 {
34481 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34482 }
34483 {
34484 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34485 }
34486 {
34487 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34488 }
34489 {
34490 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34491 }
34492 {
34493 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34494 }
34495 {
34496 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34497 }
34498 {
34499 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34500 }
34501 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34502 {
34503 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34504 }
34505 {
34506 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34507 }
34508 {
34509 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34510 }
34511 {
34512 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34513 }
34514 {
34515 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34516 }
34517 {
34518 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34519 }
34520 {
34521 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34522 }
34523 {
34524 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34525 }
34526 {
34527 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34528 }
34529 {
34530 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34531 }
34532 {
34533 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34534 }
34535 {
34536 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34537 }
34538 {
34539 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34540 }
34541 {
34542 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34543 }
34544 {
34545 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34546 }
34547 {
34548 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34549 }
34550 {
34551 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34552 }
34553 {
34554 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34555 }
34556 {
34557 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34558 }
34559 {
34560 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34561 }
34562 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34563 {
34564 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34565 }
34566 {
34567 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34568 }
34569 {
34570 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34571 }
34572 {
34573 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34574 }
34575 {
34576 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34577 }
34578 {
34579 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34580 }
34581 {
34582 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34583 }
34584 {
34585 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34586 }
34587 {
34588 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34589 }
34590 {
34591 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34592 }
34593 {
34594 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34595 }
34596 {
34597 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34598 }
34599
34600 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34601 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34602 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34603 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34604
34605 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34606 }
34607
wxWidgets (Impactor)