]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / msw / _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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 iconIndex = loc.GetIndex();
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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2545 #define SWIG_From_unsigned_SS_int SWIG_From_long
2546 /*@@*/
2547 #else
2548 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2971 PyObject* pyList = NULL;
2972 wxArrayVideoModes arr = self->GetModes(mode);
2973 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2974 pyList = PyList_New(0);
2975 for (int i=0; i < arr.GetCount(); i++) {
2976 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2977 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2978 PyList_Append(pyList, pyObj);
2979 Py_DECREF(pyObj);
2980 }
2981 wxPyEndBlockThreads(blocked);
2982 return pyList;
2983 }
2984
2985 #include <wx/stdpaths.h>
2986
2987 static wxStandardPaths *StandardPaths_Get(){
2988 return (wxStandardPaths*) &wxStandardPaths::Get();
2989 }
2990 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2991 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2992 #ifdef __cplusplus
2993 extern "C" {
2994 #endif
2995 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2996 PyObject *resultobj;
2997 wxSystemColour arg1 ;
2998 wxColour result;
2999 PyObject * obj0 = 0 ;
3000 char *kwnames[] = {
3001 (char *) "index", NULL
3002 };
3003
3004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3005 {
3006 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3007 if (SWIG_arg_fail(1)) SWIG_fail;
3008 }
3009 {
3010 if (!wxPyCheckForApp()) SWIG_fail;
3011 PyThreadState* __tstate = wxPyBeginAllowThreads();
3012 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3013
3014 wxPyEndAllowThreads(__tstate);
3015 if (PyErr_Occurred()) SWIG_fail;
3016 }
3017 {
3018 wxColour * resultptr;
3019 resultptr = new wxColour((wxColour &)(result));
3020 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3021 }
3022 return resultobj;
3023 fail:
3024 return NULL;
3025 }
3026
3027
3028 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3029 PyObject *resultobj;
3030 wxSystemFont arg1 ;
3031 wxFont result;
3032 PyObject * obj0 = 0 ;
3033 char *kwnames[] = {
3034 (char *) "index", NULL
3035 };
3036
3037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3038 {
3039 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3040 if (SWIG_arg_fail(1)) SWIG_fail;
3041 }
3042 {
3043 if (!wxPyCheckForApp()) SWIG_fail;
3044 PyThreadState* __tstate = wxPyBeginAllowThreads();
3045 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3046
3047 wxPyEndAllowThreads(__tstate);
3048 if (PyErr_Occurred()) SWIG_fail;
3049 }
3050 {
3051 wxFont * resultptr;
3052 resultptr = new wxFont((wxFont &)(result));
3053 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3054 }
3055 return resultobj;
3056 fail:
3057 return NULL;
3058 }
3059
3060
3061 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3062 PyObject *resultobj;
3063 wxSystemMetric arg1 ;
3064 wxWindow *arg2 = (wxWindow *) NULL ;
3065 int result;
3066 PyObject * obj0 = 0 ;
3067 PyObject * obj1 = 0 ;
3068 char *kwnames[] = {
3069 (char *) "index",(char *) "win", NULL
3070 };
3071
3072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3073 {
3074 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3075 if (SWIG_arg_fail(1)) SWIG_fail;
3076 }
3077 if (obj1) {
3078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3079 if (SWIG_arg_fail(2)) SWIG_fail;
3080 }
3081 {
3082 if (!wxPyCheckForApp()) SWIG_fail;
3083 PyThreadState* __tstate = wxPyBeginAllowThreads();
3084 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3085
3086 wxPyEndAllowThreads(__tstate);
3087 if (PyErr_Occurred()) SWIG_fail;
3088 }
3089 {
3090 resultobj = SWIG_From_int((int)(result));
3091 }
3092 return resultobj;
3093 fail:
3094 return NULL;
3095 }
3096
3097
3098 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3099 PyObject *resultobj;
3100 wxSystemFeature arg1 ;
3101 bool result;
3102 PyObject * obj0 = 0 ;
3103 char *kwnames[] = {
3104 (char *) "index", NULL
3105 };
3106
3107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3108 {
3109 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3110 if (SWIG_arg_fail(1)) SWIG_fail;
3111 }
3112 {
3113 if (!wxPyCheckForApp()) SWIG_fail;
3114 PyThreadState* __tstate = wxPyBeginAllowThreads();
3115 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3116
3117 wxPyEndAllowThreads(__tstate);
3118 if (PyErr_Occurred()) SWIG_fail;
3119 }
3120 {
3121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3122 }
3123 return resultobj;
3124 fail:
3125 return NULL;
3126 }
3127
3128
3129 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3130 PyObject *resultobj;
3131 wxSystemScreenType result;
3132 char *kwnames[] = {
3133 NULL
3134 };
3135
3136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3137 {
3138 if (!wxPyCheckForApp()) SWIG_fail;
3139 PyThreadState* __tstate = wxPyBeginAllowThreads();
3140 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3141
3142 wxPyEndAllowThreads(__tstate);
3143 if (PyErr_Occurred()) SWIG_fail;
3144 }
3145 resultobj = SWIG_From_int((result));
3146 return resultobj;
3147 fail:
3148 return NULL;
3149 }
3150
3151
3152 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3153 PyObject *resultobj;
3154 wxSystemScreenType arg1 ;
3155 PyObject * obj0 = 0 ;
3156 char *kwnames[] = {
3157 (char *) "screen", NULL
3158 };
3159
3160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3161 {
3162 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3163 if (SWIG_arg_fail(1)) SWIG_fail;
3164 }
3165 {
3166 if (!wxPyCheckForApp()) SWIG_fail;
3167 PyThreadState* __tstate = wxPyBeginAllowThreads();
3168 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3169
3170 wxPyEndAllowThreads(__tstate);
3171 if (PyErr_Occurred()) SWIG_fail;
3172 }
3173 Py_INCREF(Py_None); resultobj = Py_None;
3174 return resultobj;
3175 fail:
3176 return NULL;
3177 }
3178
3179
3180 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3181 PyObject *obj;
3182 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3183 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3184 Py_INCREF(obj);
3185 return Py_BuildValue((char *)"");
3186 }
3187 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3188 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3189 return 1;
3190 }
3191
3192
3193 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3194 PyObject *pyobj;
3195
3196 {
3197 #if wxUSE_UNICODE
3198 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3199 #else
3200 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3201 #endif
3202 }
3203 return pyobj;
3204 }
3205
3206
3207 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3208 PyObject *resultobj;
3209 wxSystemOptions *result;
3210 char *kwnames[] = {
3211 NULL
3212 };
3213
3214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3215 {
3216 PyThreadState* __tstate = wxPyBeginAllowThreads();
3217 result = (wxSystemOptions *)new wxSystemOptions();
3218
3219 wxPyEndAllowThreads(__tstate);
3220 if (PyErr_Occurred()) SWIG_fail;
3221 }
3222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3223 return resultobj;
3224 fail:
3225 return NULL;
3226 }
3227
3228
3229 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3230 PyObject *resultobj;
3231 wxString *arg1 = 0 ;
3232 wxString *arg2 = 0 ;
3233 bool temp1 = false ;
3234 bool temp2 = false ;
3235 PyObject * obj0 = 0 ;
3236 PyObject * obj1 = 0 ;
3237 char *kwnames[] = {
3238 (char *) "name",(char *) "value", NULL
3239 };
3240
3241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3242 {
3243 arg1 = wxString_in_helper(obj0);
3244 if (arg1 == NULL) SWIG_fail;
3245 temp1 = true;
3246 }
3247 {
3248 arg2 = wxString_in_helper(obj1);
3249 if (arg2 == NULL) SWIG_fail;
3250 temp2 = true;
3251 }
3252 {
3253 PyThreadState* __tstate = wxPyBeginAllowThreads();
3254 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3255
3256 wxPyEndAllowThreads(__tstate);
3257 if (PyErr_Occurred()) SWIG_fail;
3258 }
3259 Py_INCREF(Py_None); resultobj = Py_None;
3260 {
3261 if (temp1)
3262 delete arg1;
3263 }
3264 {
3265 if (temp2)
3266 delete arg2;
3267 }
3268 return resultobj;
3269 fail:
3270 {
3271 if (temp1)
3272 delete arg1;
3273 }
3274 {
3275 if (temp2)
3276 delete arg2;
3277 }
3278 return NULL;
3279 }
3280
3281
3282 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3283 PyObject *resultobj;
3284 wxString *arg1 = 0 ;
3285 int arg2 ;
3286 bool temp1 = false ;
3287 PyObject * obj0 = 0 ;
3288 PyObject * obj1 = 0 ;
3289 char *kwnames[] = {
3290 (char *) "name",(char *) "value", NULL
3291 };
3292
3293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3294 {
3295 arg1 = wxString_in_helper(obj0);
3296 if (arg1 == NULL) SWIG_fail;
3297 temp1 = true;
3298 }
3299 {
3300 arg2 = (int)(SWIG_As_int(obj1));
3301 if (SWIG_arg_fail(2)) SWIG_fail;
3302 }
3303 {
3304 PyThreadState* __tstate = wxPyBeginAllowThreads();
3305 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3306
3307 wxPyEndAllowThreads(__tstate);
3308 if (PyErr_Occurred()) SWIG_fail;
3309 }
3310 Py_INCREF(Py_None); resultobj = Py_None;
3311 {
3312 if (temp1)
3313 delete arg1;
3314 }
3315 return resultobj;
3316 fail:
3317 {
3318 if (temp1)
3319 delete arg1;
3320 }
3321 return NULL;
3322 }
3323
3324
3325 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3326 PyObject *resultobj;
3327 wxString *arg1 = 0 ;
3328 wxString result;
3329 bool temp1 = false ;
3330 PyObject * obj0 = 0 ;
3331 char *kwnames[] = {
3332 (char *) "name", NULL
3333 };
3334
3335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3336 {
3337 arg1 = wxString_in_helper(obj0);
3338 if (arg1 == NULL) SWIG_fail;
3339 temp1 = true;
3340 }
3341 {
3342 PyThreadState* __tstate = wxPyBeginAllowThreads();
3343 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3344
3345 wxPyEndAllowThreads(__tstate);
3346 if (PyErr_Occurred()) SWIG_fail;
3347 }
3348 {
3349 #if wxUSE_UNICODE
3350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3351 #else
3352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3353 #endif
3354 }
3355 {
3356 if (temp1)
3357 delete arg1;
3358 }
3359 return resultobj;
3360 fail:
3361 {
3362 if (temp1)
3363 delete arg1;
3364 }
3365 return NULL;
3366 }
3367
3368
3369 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3370 PyObject *resultobj;
3371 wxString *arg1 = 0 ;
3372 int result;
3373 bool temp1 = false ;
3374 PyObject * obj0 = 0 ;
3375 char *kwnames[] = {
3376 (char *) "name", NULL
3377 };
3378
3379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3380 {
3381 arg1 = wxString_in_helper(obj0);
3382 if (arg1 == NULL) SWIG_fail;
3383 temp1 = true;
3384 }
3385 {
3386 PyThreadState* __tstate = wxPyBeginAllowThreads();
3387 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3388
3389 wxPyEndAllowThreads(__tstate);
3390 if (PyErr_Occurred()) SWIG_fail;
3391 }
3392 {
3393 resultobj = SWIG_From_int((int)(result));
3394 }
3395 {
3396 if (temp1)
3397 delete arg1;
3398 }
3399 return resultobj;
3400 fail:
3401 {
3402 if (temp1)
3403 delete arg1;
3404 }
3405 return NULL;
3406 }
3407
3408
3409 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3410 PyObject *resultobj;
3411 wxString *arg1 = 0 ;
3412 bool result;
3413 bool temp1 = false ;
3414 PyObject * obj0 = 0 ;
3415 char *kwnames[] = {
3416 (char *) "name", NULL
3417 };
3418
3419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3420 {
3421 arg1 = wxString_in_helper(obj0);
3422 if (arg1 == NULL) SWIG_fail;
3423 temp1 = true;
3424 }
3425 {
3426 PyThreadState* __tstate = wxPyBeginAllowThreads();
3427 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3428
3429 wxPyEndAllowThreads(__tstate);
3430 if (PyErr_Occurred()) SWIG_fail;
3431 }
3432 {
3433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3434 }
3435 {
3436 if (temp1)
3437 delete arg1;
3438 }
3439 return resultobj;
3440 fail:
3441 {
3442 if (temp1)
3443 delete arg1;
3444 }
3445 return NULL;
3446 }
3447
3448
3449 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3450 PyObject *resultobj;
3451 wxString *arg1 = 0 ;
3452 bool result;
3453 bool temp1 = false ;
3454 PyObject * obj0 = 0 ;
3455 char *kwnames[] = {
3456 (char *) "name", NULL
3457 };
3458
3459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3460 {
3461 arg1 = wxString_in_helper(obj0);
3462 if (arg1 == NULL) SWIG_fail;
3463 temp1 = true;
3464 }
3465 {
3466 PyThreadState* __tstate = wxPyBeginAllowThreads();
3467 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3468
3469 wxPyEndAllowThreads(__tstate);
3470 if (PyErr_Occurred()) SWIG_fail;
3471 }
3472 {
3473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3474 }
3475 {
3476 if (temp1)
3477 delete arg1;
3478 }
3479 return resultobj;
3480 fail:
3481 {
3482 if (temp1)
3483 delete arg1;
3484 }
3485 return NULL;
3486 }
3487
3488
3489 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3490 PyObject *obj;
3491 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3492 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3493 Py_INCREF(obj);
3494 return Py_BuildValue((char *)"");
3495 }
3496 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3497 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3498 return 1;
3499 }
3500
3501
3502 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3503 PyObject *pyobj;
3504
3505 {
3506 #if wxUSE_UNICODE
3507 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3508 #else
3509 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3510 #endif
3511 }
3512 return pyobj;
3513 }
3514
3515
3516 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3517 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3518 return 1;
3519 }
3520
3521
3522 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3523 PyObject *pyobj;
3524
3525 {
3526 #if wxUSE_UNICODE
3527 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3528 #else
3529 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3530 #endif
3531 }
3532 return pyobj;
3533 }
3534
3535
3536 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3537 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3538 return 1;
3539 }
3540
3541
3542 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3543 PyObject *pyobj;
3544
3545 {
3546 #if wxUSE_UNICODE
3547 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3548 #else
3549 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3550 #endif
3551 }
3552 return pyobj;
3553 }
3554
3555
3556 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3557 PyObject *resultobj;
3558 long result;
3559 char *kwnames[] = {
3560 NULL
3561 };
3562
3563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3564 {
3565 PyThreadState* __tstate = wxPyBeginAllowThreads();
3566 result = (long)wxNewId();
3567
3568 wxPyEndAllowThreads(__tstate);
3569 if (PyErr_Occurred()) SWIG_fail;
3570 }
3571 {
3572 resultobj = SWIG_From_long((long)(result));
3573 }
3574 return resultobj;
3575 fail:
3576 return NULL;
3577 }
3578
3579
3580 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3581 PyObject *resultobj;
3582 long arg1 ;
3583 PyObject * obj0 = 0 ;
3584 char *kwnames[] = {
3585 (char *) "id", NULL
3586 };
3587
3588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3589 {
3590 arg1 = (long)(SWIG_As_long(obj0));
3591 if (SWIG_arg_fail(1)) SWIG_fail;
3592 }
3593 {
3594 PyThreadState* __tstate = wxPyBeginAllowThreads();
3595 wxRegisterId(arg1);
3596
3597 wxPyEndAllowThreads(__tstate);
3598 if (PyErr_Occurred()) SWIG_fail;
3599 }
3600 Py_INCREF(Py_None); resultobj = Py_None;
3601 return resultobj;
3602 fail:
3603 return NULL;
3604 }
3605
3606
3607 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3608 PyObject *resultobj;
3609 long result;
3610 char *kwnames[] = {
3611 NULL
3612 };
3613
3614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3615 {
3616 PyThreadState* __tstate = wxPyBeginAllowThreads();
3617 result = (long)wxGetCurrentId();
3618
3619 wxPyEndAllowThreads(__tstate);
3620 if (PyErr_Occurred()) SWIG_fail;
3621 }
3622 {
3623 resultobj = SWIG_From_long((long)(result));
3624 }
3625 return resultobj;
3626 fail:
3627 return NULL;
3628 }
3629
3630
3631 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3632 PyObject *resultobj;
3633 int arg1 ;
3634 bool result;
3635 PyObject * obj0 = 0 ;
3636 char *kwnames[] = {
3637 (char *) "id", NULL
3638 };
3639
3640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3641 {
3642 arg1 = (int)(SWIG_As_int(obj0));
3643 if (SWIG_arg_fail(1)) SWIG_fail;
3644 }
3645 {
3646 PyThreadState* __tstate = wxPyBeginAllowThreads();
3647 result = (bool)wxIsStockID(arg1);
3648
3649 wxPyEndAllowThreads(__tstate);
3650 if (PyErr_Occurred()) SWIG_fail;
3651 }
3652 {
3653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3654 }
3655 return resultobj;
3656 fail:
3657 return NULL;
3658 }
3659
3660
3661 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3662 PyObject *resultobj;
3663 int arg1 ;
3664 wxString *arg2 = 0 ;
3665 bool result;
3666 bool temp2 = false ;
3667 PyObject * obj0 = 0 ;
3668 PyObject * obj1 = 0 ;
3669 char *kwnames[] = {
3670 (char *) "id",(char *) "label", NULL
3671 };
3672
3673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3674 {
3675 arg1 = (int)(SWIG_As_int(obj0));
3676 if (SWIG_arg_fail(1)) SWIG_fail;
3677 }
3678 {
3679 arg2 = wxString_in_helper(obj1);
3680 if (arg2 == NULL) SWIG_fail;
3681 temp2 = true;
3682 }
3683 {
3684 PyThreadState* __tstate = wxPyBeginAllowThreads();
3685 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3686
3687 wxPyEndAllowThreads(__tstate);
3688 if (PyErr_Occurred()) SWIG_fail;
3689 }
3690 {
3691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3692 }
3693 {
3694 if (temp2)
3695 delete arg2;
3696 }
3697 return resultobj;
3698 fail:
3699 {
3700 if (temp2)
3701 delete arg2;
3702 }
3703 return NULL;
3704 }
3705
3706
3707 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3708 PyObject *resultobj;
3709 int arg1 ;
3710 bool arg2 = (bool) true ;
3711 wxString arg3 = (wxString) wxPyEmptyString ;
3712 wxString result;
3713 PyObject * obj0 = 0 ;
3714 PyObject * obj1 = 0 ;
3715 PyObject * obj2 = 0 ;
3716 char *kwnames[] = {
3717 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3718 };
3719
3720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3721 {
3722 arg1 = (int)(SWIG_As_int(obj0));
3723 if (SWIG_arg_fail(1)) SWIG_fail;
3724 }
3725 if (obj1) {
3726 {
3727 arg2 = (bool)(SWIG_As_bool(obj1));
3728 if (SWIG_arg_fail(2)) SWIG_fail;
3729 }
3730 }
3731 if (obj2) {
3732 {
3733 wxString* sptr = wxString_in_helper(obj2);
3734 if (sptr == NULL) SWIG_fail;
3735 arg3 = *sptr;
3736 delete sptr;
3737 }
3738 }
3739 {
3740 PyThreadState* __tstate = wxPyBeginAllowThreads();
3741 result = wxGetStockLabel(arg1,arg2,arg3);
3742
3743 wxPyEndAllowThreads(__tstate);
3744 if (PyErr_Occurred()) SWIG_fail;
3745 }
3746 {
3747 #if wxUSE_UNICODE
3748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3749 #else
3750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3751 #endif
3752 }
3753 return resultobj;
3754 fail:
3755 return NULL;
3756 }
3757
3758
3759 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3760 PyObject *resultobj;
3761 char *kwnames[] = {
3762 NULL
3763 };
3764
3765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3766 {
3767 if (!wxPyCheckForApp()) SWIG_fail;
3768 PyThreadState* __tstate = wxPyBeginAllowThreads();
3769 wxBell();
3770
3771 wxPyEndAllowThreads(__tstate);
3772 if (PyErr_Occurred()) SWIG_fail;
3773 }
3774 Py_INCREF(Py_None); resultobj = Py_None;
3775 return resultobj;
3776 fail:
3777 return NULL;
3778 }
3779
3780
3781 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3782 PyObject *resultobj;
3783 char *kwnames[] = {
3784 NULL
3785 };
3786
3787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3788 {
3789 if (!wxPyCheckForApp()) SWIG_fail;
3790 PyThreadState* __tstate = wxPyBeginAllowThreads();
3791 wxEndBusyCursor();
3792
3793 wxPyEndAllowThreads(__tstate);
3794 if (PyErr_Occurred()) SWIG_fail;
3795 }
3796 Py_INCREF(Py_None); resultobj = Py_None;
3797 return resultobj;
3798 fail:
3799 return NULL;
3800 }
3801
3802
3803 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3804 PyObject *resultobj;
3805 bool arg1 = (bool) true ;
3806 long result;
3807 PyObject * obj0 = 0 ;
3808 char *kwnames[] = {
3809 (char *) "resetTimer", NULL
3810 };
3811
3812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3813 if (obj0) {
3814 {
3815 arg1 = (bool)(SWIG_As_bool(obj0));
3816 if (SWIG_arg_fail(1)) SWIG_fail;
3817 }
3818 }
3819 {
3820 PyThreadState* __tstate = wxPyBeginAllowThreads();
3821 result = (long)wxGetElapsedTime(arg1);
3822
3823 wxPyEndAllowThreads(__tstate);
3824 if (PyErr_Occurred()) SWIG_fail;
3825 }
3826 {
3827 resultobj = SWIG_From_long((long)(result));
3828 }
3829 return resultobj;
3830 fail:
3831 return NULL;
3832 }
3833
3834
3835 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3836 PyObject *resultobj;
3837 int *arg1 = (int *) 0 ;
3838 int *arg2 = (int *) 0 ;
3839 int temp1 ;
3840 int res1 = 0 ;
3841 int temp2 ;
3842 int res2 = 0 ;
3843 char *kwnames[] = {
3844 NULL
3845 };
3846
3847 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3848 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3850 {
3851 if (!wxPyCheckForApp()) SWIG_fail;
3852 PyThreadState* __tstate = wxPyBeginAllowThreads();
3853 wxGetMousePosition(arg1,arg2);
3854
3855 wxPyEndAllowThreads(__tstate);
3856 if (PyErr_Occurred()) SWIG_fail;
3857 }
3858 Py_INCREF(Py_None); resultobj = Py_None;
3859 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3860 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3861 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3862 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3863 return resultobj;
3864 fail:
3865 return NULL;
3866 }
3867
3868
3869 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3870 PyObject *resultobj;
3871 bool result;
3872 char *kwnames[] = {
3873 NULL
3874 };
3875
3876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3877 {
3878 PyThreadState* __tstate = wxPyBeginAllowThreads();
3879 result = (bool)wxIsBusy();
3880
3881 wxPyEndAllowThreads(__tstate);
3882 if (PyErr_Occurred()) SWIG_fail;
3883 }
3884 {
3885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3886 }
3887 return resultobj;
3888 fail:
3889 return NULL;
3890 }
3891
3892
3893 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3894 PyObject *resultobj;
3895 wxString result;
3896 char *kwnames[] = {
3897 NULL
3898 };
3899
3900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3901 {
3902 PyThreadState* __tstate = wxPyBeginAllowThreads();
3903 result = wxNow();
3904
3905 wxPyEndAllowThreads(__tstate);
3906 if (PyErr_Occurred()) SWIG_fail;
3907 }
3908 {
3909 #if wxUSE_UNICODE
3910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3911 #else
3912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3913 #endif
3914 }
3915 return resultobj;
3916 fail:
3917 return NULL;
3918 }
3919
3920
3921 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3922 PyObject *resultobj;
3923 wxString const &arg1_defvalue = wxPyEmptyString ;
3924 wxString *arg1 = (wxString *) &arg1_defvalue ;
3925 bool result;
3926 bool temp1 = false ;
3927 PyObject * obj0 = 0 ;
3928 char *kwnames[] = {
3929 (char *) "command", NULL
3930 };
3931
3932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3933 if (obj0) {
3934 {
3935 arg1 = wxString_in_helper(obj0);
3936 if (arg1 == NULL) SWIG_fail;
3937 temp1 = true;
3938 }
3939 }
3940 {
3941 PyThreadState* __tstate = wxPyBeginAllowThreads();
3942 result = (bool)wxShell((wxString const &)*arg1);
3943
3944 wxPyEndAllowThreads(__tstate);
3945 if (PyErr_Occurred()) SWIG_fail;
3946 }
3947 {
3948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3949 }
3950 {
3951 if (temp1)
3952 delete arg1;
3953 }
3954 return resultobj;
3955 fail:
3956 {
3957 if (temp1)
3958 delete arg1;
3959 }
3960 return NULL;
3961 }
3962
3963
3964 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3965 PyObject *resultobj;
3966 char *kwnames[] = {
3967 NULL
3968 };
3969
3970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3971 {
3972 PyThreadState* __tstate = wxPyBeginAllowThreads();
3973 wxStartTimer();
3974
3975 wxPyEndAllowThreads(__tstate);
3976 if (PyErr_Occurred()) SWIG_fail;
3977 }
3978 Py_INCREF(Py_None); resultobj = Py_None;
3979 return resultobj;
3980 fail:
3981 return NULL;
3982 }
3983
3984
3985 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3986 PyObject *resultobj;
3987 int *arg1 = (int *) 0 ;
3988 int *arg2 = (int *) 0 ;
3989 int result;
3990 int temp1 ;
3991 int res1 = 0 ;
3992 int temp2 ;
3993 int res2 = 0 ;
3994 char *kwnames[] = {
3995 NULL
3996 };
3997
3998 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3999 arg2 = &temp2; res2 = SWIG_NEWOBJ;
4000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
4001 {
4002 PyThreadState* __tstate = wxPyBeginAllowThreads();
4003 result = (int)wxGetOsVersion(arg1,arg2);
4004
4005 wxPyEndAllowThreads(__tstate);
4006 if (PyErr_Occurred()) SWIG_fail;
4007 }
4008 {
4009 resultobj = SWIG_From_int((int)(result));
4010 }
4011 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4012 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4013 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4014 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4015 return resultobj;
4016 fail:
4017 return NULL;
4018 }
4019
4020
4021 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4022 PyObject *resultobj;
4023 wxString result;
4024 char *kwnames[] = {
4025 NULL
4026 };
4027
4028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4029 {
4030 PyThreadState* __tstate = wxPyBeginAllowThreads();
4031 result = wxGetOsDescription();
4032
4033 wxPyEndAllowThreads(__tstate);
4034 if (PyErr_Occurred()) SWIG_fail;
4035 }
4036 {
4037 #if wxUSE_UNICODE
4038 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4039 #else
4040 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4041 #endif
4042 }
4043 return resultobj;
4044 fail:
4045 return NULL;
4046 }
4047
4048
4049 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4050 PyObject *resultobj;
4051 long result;
4052 char *kwnames[] = {
4053 NULL
4054 };
4055
4056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4057 {
4058 PyThreadState* __tstate = wxPyBeginAllowThreads();
4059 result = (long)wxGetFreeMemory();
4060
4061 wxPyEndAllowThreads(__tstate);
4062 if (PyErr_Occurred()) SWIG_fail;
4063 }
4064 {
4065 resultobj = SWIG_From_long((long)(result));
4066 }
4067 return resultobj;
4068 fail:
4069 return NULL;
4070 }
4071
4072
4073 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4074 PyObject *resultobj;
4075 wxShutdownFlags arg1 ;
4076 bool result;
4077 PyObject * obj0 = 0 ;
4078 char *kwnames[] = {
4079 (char *) "wFlags", NULL
4080 };
4081
4082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4083 {
4084 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4085 if (SWIG_arg_fail(1)) SWIG_fail;
4086 }
4087 {
4088 if (!wxPyCheckForApp()) SWIG_fail;
4089 PyThreadState* __tstate = wxPyBeginAllowThreads();
4090 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4091
4092 wxPyEndAllowThreads(__tstate);
4093 if (PyErr_Occurred()) SWIG_fail;
4094 }
4095 {
4096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4097 }
4098 return resultobj;
4099 fail:
4100 return NULL;
4101 }
4102
4103
4104 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4105 PyObject *resultobj;
4106 int arg1 ;
4107 PyObject * obj0 = 0 ;
4108 char *kwnames[] = {
4109 (char *) "secs", NULL
4110 };
4111
4112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4113 {
4114 arg1 = (int)(SWIG_As_int(obj0));
4115 if (SWIG_arg_fail(1)) SWIG_fail;
4116 }
4117 {
4118 PyThreadState* __tstate = wxPyBeginAllowThreads();
4119 wxSleep(arg1);
4120
4121 wxPyEndAllowThreads(__tstate);
4122 if (PyErr_Occurred()) SWIG_fail;
4123 }
4124 Py_INCREF(Py_None); resultobj = Py_None;
4125 return resultobj;
4126 fail:
4127 return NULL;
4128 }
4129
4130
4131 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4132 PyObject *resultobj;
4133 unsigned long arg1 ;
4134 PyObject * obj0 = 0 ;
4135 char *kwnames[] = {
4136 (char *) "milliseconds", NULL
4137 };
4138
4139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4140 {
4141 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4142 if (SWIG_arg_fail(1)) SWIG_fail;
4143 }
4144 {
4145 PyThreadState* __tstate = wxPyBeginAllowThreads();
4146 wxMilliSleep(arg1);
4147
4148 wxPyEndAllowThreads(__tstate);
4149 if (PyErr_Occurred()) SWIG_fail;
4150 }
4151 Py_INCREF(Py_None); resultobj = Py_None;
4152 return resultobj;
4153 fail:
4154 return NULL;
4155 }
4156
4157
4158 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4159 PyObject *resultobj;
4160 unsigned long arg1 ;
4161 PyObject * obj0 = 0 ;
4162 char *kwnames[] = {
4163 (char *) "microseconds", NULL
4164 };
4165
4166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4167 {
4168 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4169 if (SWIG_arg_fail(1)) SWIG_fail;
4170 }
4171 {
4172 PyThreadState* __tstate = wxPyBeginAllowThreads();
4173 wxMicroSleep(arg1);
4174
4175 wxPyEndAllowThreads(__tstate);
4176 if (PyErr_Occurred()) SWIG_fail;
4177 }
4178 Py_INCREF(Py_None); resultobj = Py_None;
4179 return resultobj;
4180 fail:
4181 return NULL;
4182 }
4183
4184
4185 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4186 PyObject *resultobj;
4187 bool arg1 ;
4188 PyObject * obj0 = 0 ;
4189 char *kwnames[] = {
4190 (char *) "enable", NULL
4191 };
4192
4193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4194 {
4195 arg1 = (bool)(SWIG_As_bool(obj0));
4196 if (SWIG_arg_fail(1)) SWIG_fail;
4197 }
4198 {
4199 PyThreadState* __tstate = wxPyBeginAllowThreads();
4200 wxEnableTopLevelWindows(arg1);
4201
4202 wxPyEndAllowThreads(__tstate);
4203 if (PyErr_Occurred()) SWIG_fail;
4204 }
4205 Py_INCREF(Py_None); resultobj = Py_None;
4206 return resultobj;
4207 fail:
4208 return NULL;
4209 }
4210
4211
4212 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4213 PyObject *resultobj;
4214 wxString *arg1 = 0 ;
4215 wxString result;
4216 bool temp1 = false ;
4217 PyObject * obj0 = 0 ;
4218 char *kwnames[] = {
4219 (char *) "in", NULL
4220 };
4221
4222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4223 {
4224 arg1 = wxString_in_helper(obj0);
4225 if (arg1 == NULL) SWIG_fail;
4226 temp1 = true;
4227 }
4228 {
4229 PyThreadState* __tstate = wxPyBeginAllowThreads();
4230 result = wxStripMenuCodes((wxString const &)*arg1);
4231
4232 wxPyEndAllowThreads(__tstate);
4233 if (PyErr_Occurred()) SWIG_fail;
4234 }
4235 {
4236 #if wxUSE_UNICODE
4237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4238 #else
4239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4240 #endif
4241 }
4242 {
4243 if (temp1)
4244 delete arg1;
4245 }
4246 return resultobj;
4247 fail:
4248 {
4249 if (temp1)
4250 delete arg1;
4251 }
4252 return NULL;
4253 }
4254
4255
4256 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4257 PyObject *resultobj;
4258 wxString result;
4259 char *kwnames[] = {
4260 NULL
4261 };
4262
4263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4264 {
4265 PyThreadState* __tstate = wxPyBeginAllowThreads();
4266 result = wxGetEmailAddress();
4267
4268 wxPyEndAllowThreads(__tstate);
4269 if (PyErr_Occurred()) SWIG_fail;
4270 }
4271 {
4272 #if wxUSE_UNICODE
4273 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4274 #else
4275 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4276 #endif
4277 }
4278 return resultobj;
4279 fail:
4280 return NULL;
4281 }
4282
4283
4284 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4285 PyObject *resultobj;
4286 wxString result;
4287 char *kwnames[] = {
4288 NULL
4289 };
4290
4291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4292 {
4293 PyThreadState* __tstate = wxPyBeginAllowThreads();
4294 result = wxGetHostName();
4295
4296 wxPyEndAllowThreads(__tstate);
4297 if (PyErr_Occurred()) SWIG_fail;
4298 }
4299 {
4300 #if wxUSE_UNICODE
4301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4302 #else
4303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4304 #endif
4305 }
4306 return resultobj;
4307 fail:
4308 return NULL;
4309 }
4310
4311
4312 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4313 PyObject *resultobj;
4314 wxString result;
4315 char *kwnames[] = {
4316 NULL
4317 };
4318
4319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4320 {
4321 PyThreadState* __tstate = wxPyBeginAllowThreads();
4322 result = wxGetFullHostName();
4323
4324 wxPyEndAllowThreads(__tstate);
4325 if (PyErr_Occurred()) SWIG_fail;
4326 }
4327 {
4328 #if wxUSE_UNICODE
4329 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4330 #else
4331 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4332 #endif
4333 }
4334 return resultobj;
4335 fail:
4336 return NULL;
4337 }
4338
4339
4340 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4341 PyObject *resultobj;
4342 wxString result;
4343 char *kwnames[] = {
4344 NULL
4345 };
4346
4347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4348 {
4349 PyThreadState* __tstate = wxPyBeginAllowThreads();
4350 result = wxGetUserId();
4351
4352 wxPyEndAllowThreads(__tstate);
4353 if (PyErr_Occurred()) SWIG_fail;
4354 }
4355 {
4356 #if wxUSE_UNICODE
4357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4358 #else
4359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4360 #endif
4361 }
4362 return resultobj;
4363 fail:
4364 return NULL;
4365 }
4366
4367
4368 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4369 PyObject *resultobj;
4370 wxString result;
4371 char *kwnames[] = {
4372 NULL
4373 };
4374
4375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4376 {
4377 PyThreadState* __tstate = wxPyBeginAllowThreads();
4378 result = wxGetUserName();
4379
4380 wxPyEndAllowThreads(__tstate);
4381 if (PyErr_Occurred()) SWIG_fail;
4382 }
4383 {
4384 #if wxUSE_UNICODE
4385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4386 #else
4387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4388 #endif
4389 }
4390 return resultobj;
4391 fail:
4392 return NULL;
4393 }
4394
4395
4396 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4397 PyObject *resultobj;
4398 wxString result;
4399 char *kwnames[] = {
4400 NULL
4401 };
4402
4403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4404 {
4405 PyThreadState* __tstate = wxPyBeginAllowThreads();
4406 result = wxGetHomeDir();
4407
4408 wxPyEndAllowThreads(__tstate);
4409 if (PyErr_Occurred()) SWIG_fail;
4410 }
4411 {
4412 #if wxUSE_UNICODE
4413 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4414 #else
4415 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4416 #endif
4417 }
4418 return resultobj;
4419 fail:
4420 return NULL;
4421 }
4422
4423
4424 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4425 PyObject *resultobj;
4426 wxString const &arg1_defvalue = wxPyEmptyString ;
4427 wxString *arg1 = (wxString *) &arg1_defvalue ;
4428 wxString result;
4429 bool temp1 = false ;
4430 PyObject * obj0 = 0 ;
4431 char *kwnames[] = {
4432 (char *) "user", NULL
4433 };
4434
4435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4436 if (obj0) {
4437 {
4438 arg1 = wxString_in_helper(obj0);
4439 if (arg1 == NULL) SWIG_fail;
4440 temp1 = true;
4441 }
4442 }
4443 {
4444 PyThreadState* __tstate = wxPyBeginAllowThreads();
4445 result = wxGetUserHome((wxString const &)*arg1);
4446
4447 wxPyEndAllowThreads(__tstate);
4448 if (PyErr_Occurred()) SWIG_fail;
4449 }
4450 {
4451 #if wxUSE_UNICODE
4452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4453 #else
4454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4455 #endif
4456 }
4457 {
4458 if (temp1)
4459 delete arg1;
4460 }
4461 return resultobj;
4462 fail:
4463 {
4464 if (temp1)
4465 delete arg1;
4466 }
4467 return NULL;
4468 }
4469
4470
4471 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4472 PyObject *resultobj;
4473 unsigned long result;
4474 char *kwnames[] = {
4475 NULL
4476 };
4477
4478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4479 {
4480 PyThreadState* __tstate = wxPyBeginAllowThreads();
4481 result = (unsigned long)wxGetProcessId();
4482
4483 wxPyEndAllowThreads(__tstate);
4484 if (PyErr_Occurred()) SWIG_fail;
4485 }
4486 {
4487 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4488 }
4489 return resultobj;
4490 fail:
4491 return NULL;
4492 }
4493
4494
4495 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4496 PyObject *resultobj;
4497 char *kwnames[] = {
4498 NULL
4499 };
4500
4501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4502 {
4503 PyThreadState* __tstate = wxPyBeginAllowThreads();
4504 wxTrap();
4505
4506 wxPyEndAllowThreads(__tstate);
4507 if (PyErr_Occurred()) SWIG_fail;
4508 }
4509 Py_INCREF(Py_None); resultobj = Py_None;
4510 return resultobj;
4511 fail:
4512 return NULL;
4513 }
4514
4515
4516 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4517 PyObject *resultobj;
4518 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4519 wxString *arg1 = (wxString *) &arg1_defvalue ;
4520 wxString const &arg2_defvalue = wxPyEmptyString ;
4521 wxString *arg2 = (wxString *) &arg2_defvalue ;
4522 wxString const &arg3_defvalue = wxPyEmptyString ;
4523 wxString *arg3 = (wxString *) &arg3_defvalue ;
4524 wxString const &arg4_defvalue = wxPyEmptyString ;
4525 wxString *arg4 = (wxString *) &arg4_defvalue ;
4526 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4527 wxString *arg5 = (wxString *) &arg5_defvalue ;
4528 int arg6 = (int) 0 ;
4529 wxWindow *arg7 = (wxWindow *) NULL ;
4530 int arg8 = (int) -1 ;
4531 int arg9 = (int) -1 ;
4532 wxString result;
4533 bool temp1 = false ;
4534 bool temp2 = false ;
4535 bool temp3 = false ;
4536 bool temp4 = false ;
4537 bool temp5 = false ;
4538 PyObject * obj0 = 0 ;
4539 PyObject * obj1 = 0 ;
4540 PyObject * obj2 = 0 ;
4541 PyObject * obj3 = 0 ;
4542 PyObject * obj4 = 0 ;
4543 PyObject * obj5 = 0 ;
4544 PyObject * obj6 = 0 ;
4545 PyObject * obj7 = 0 ;
4546 PyObject * obj8 = 0 ;
4547 char *kwnames[] = {
4548 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4549 };
4550
4551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4552 if (obj0) {
4553 {
4554 arg1 = wxString_in_helper(obj0);
4555 if (arg1 == NULL) SWIG_fail;
4556 temp1 = true;
4557 }
4558 }
4559 if (obj1) {
4560 {
4561 arg2 = wxString_in_helper(obj1);
4562 if (arg2 == NULL) SWIG_fail;
4563 temp2 = true;
4564 }
4565 }
4566 if (obj2) {
4567 {
4568 arg3 = wxString_in_helper(obj2);
4569 if (arg3 == NULL) SWIG_fail;
4570 temp3 = true;
4571 }
4572 }
4573 if (obj3) {
4574 {
4575 arg4 = wxString_in_helper(obj3);
4576 if (arg4 == NULL) SWIG_fail;
4577 temp4 = true;
4578 }
4579 }
4580 if (obj4) {
4581 {
4582 arg5 = wxString_in_helper(obj4);
4583 if (arg5 == NULL) SWIG_fail;
4584 temp5 = true;
4585 }
4586 }
4587 if (obj5) {
4588 {
4589 arg6 = (int)(SWIG_As_int(obj5));
4590 if (SWIG_arg_fail(6)) SWIG_fail;
4591 }
4592 }
4593 if (obj6) {
4594 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4595 if (SWIG_arg_fail(7)) SWIG_fail;
4596 }
4597 if (obj7) {
4598 {
4599 arg8 = (int)(SWIG_As_int(obj7));
4600 if (SWIG_arg_fail(8)) SWIG_fail;
4601 }
4602 }
4603 if (obj8) {
4604 {
4605 arg9 = (int)(SWIG_As_int(obj8));
4606 if (SWIG_arg_fail(9)) SWIG_fail;
4607 }
4608 }
4609 {
4610 if (!wxPyCheckForApp()) SWIG_fail;
4611 PyThreadState* __tstate = wxPyBeginAllowThreads();
4612 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4613
4614 wxPyEndAllowThreads(__tstate);
4615 if (PyErr_Occurred()) SWIG_fail;
4616 }
4617 {
4618 #if wxUSE_UNICODE
4619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4620 #else
4621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4622 #endif
4623 }
4624 {
4625 if (temp1)
4626 delete arg1;
4627 }
4628 {
4629 if (temp2)
4630 delete arg2;
4631 }
4632 {
4633 if (temp3)
4634 delete arg3;
4635 }
4636 {
4637 if (temp4)
4638 delete arg4;
4639 }
4640 {
4641 if (temp5)
4642 delete arg5;
4643 }
4644 return resultobj;
4645 fail:
4646 {
4647 if (temp1)
4648 delete arg1;
4649 }
4650 {
4651 if (temp2)
4652 delete arg2;
4653 }
4654 {
4655 if (temp3)
4656 delete arg3;
4657 }
4658 {
4659 if (temp4)
4660 delete arg4;
4661 }
4662 {
4663 if (temp5)
4664 delete arg5;
4665 }
4666 return NULL;
4667 }
4668
4669
4670 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4671 PyObject *resultobj;
4672 wxString *arg1 = 0 ;
4673 wxString *arg2 = 0 ;
4674 wxString const &arg3_defvalue = wxPyEmptyString ;
4675 wxString *arg3 = (wxString *) &arg3_defvalue ;
4676 wxWindow *arg4 = (wxWindow *) NULL ;
4677 wxString result;
4678 bool temp1 = false ;
4679 bool temp2 = false ;
4680 bool temp3 = false ;
4681 PyObject * obj0 = 0 ;
4682 PyObject * obj1 = 0 ;
4683 PyObject * obj2 = 0 ;
4684 PyObject * obj3 = 0 ;
4685 char *kwnames[] = {
4686 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4687 };
4688
4689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4690 {
4691 arg1 = wxString_in_helper(obj0);
4692 if (arg1 == NULL) SWIG_fail;
4693 temp1 = true;
4694 }
4695 {
4696 arg2 = wxString_in_helper(obj1);
4697 if (arg2 == NULL) SWIG_fail;
4698 temp2 = true;
4699 }
4700 if (obj2) {
4701 {
4702 arg3 = wxString_in_helper(obj2);
4703 if (arg3 == NULL) SWIG_fail;
4704 temp3 = true;
4705 }
4706 }
4707 if (obj3) {
4708 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4709 if (SWIG_arg_fail(4)) SWIG_fail;
4710 }
4711 {
4712 if (!wxPyCheckForApp()) SWIG_fail;
4713 PyThreadState* __tstate = wxPyBeginAllowThreads();
4714 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4715
4716 wxPyEndAllowThreads(__tstate);
4717 if (PyErr_Occurred()) SWIG_fail;
4718 }
4719 {
4720 #if wxUSE_UNICODE
4721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4722 #else
4723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4724 #endif
4725 }
4726 {
4727 if (temp1)
4728 delete arg1;
4729 }
4730 {
4731 if (temp2)
4732 delete arg2;
4733 }
4734 {
4735 if (temp3)
4736 delete arg3;
4737 }
4738 return resultobj;
4739 fail:
4740 {
4741 if (temp1)
4742 delete arg1;
4743 }
4744 {
4745 if (temp2)
4746 delete arg2;
4747 }
4748 {
4749 if (temp3)
4750 delete arg3;
4751 }
4752 return NULL;
4753 }
4754
4755
4756 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4757 PyObject *resultobj;
4758 wxString *arg1 = 0 ;
4759 wxString *arg2 = 0 ;
4760 wxString const &arg3_defvalue = wxPyEmptyString ;
4761 wxString *arg3 = (wxString *) &arg3_defvalue ;
4762 wxWindow *arg4 = (wxWindow *) NULL ;
4763 wxString result;
4764 bool temp1 = false ;
4765 bool temp2 = false ;
4766 bool temp3 = false ;
4767 PyObject * obj0 = 0 ;
4768 PyObject * obj1 = 0 ;
4769 PyObject * obj2 = 0 ;
4770 PyObject * obj3 = 0 ;
4771 char *kwnames[] = {
4772 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4773 };
4774
4775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4776 {
4777 arg1 = wxString_in_helper(obj0);
4778 if (arg1 == NULL) SWIG_fail;
4779 temp1 = true;
4780 }
4781 {
4782 arg2 = wxString_in_helper(obj1);
4783 if (arg2 == NULL) SWIG_fail;
4784 temp2 = true;
4785 }
4786 if (obj2) {
4787 {
4788 arg3 = wxString_in_helper(obj2);
4789 if (arg3 == NULL) SWIG_fail;
4790 temp3 = true;
4791 }
4792 }
4793 if (obj3) {
4794 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4795 if (SWIG_arg_fail(4)) SWIG_fail;
4796 }
4797 {
4798 if (!wxPyCheckForApp()) SWIG_fail;
4799 PyThreadState* __tstate = wxPyBeginAllowThreads();
4800 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4801
4802 wxPyEndAllowThreads(__tstate);
4803 if (PyErr_Occurred()) SWIG_fail;
4804 }
4805 {
4806 #if wxUSE_UNICODE
4807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4808 #else
4809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4810 #endif
4811 }
4812 {
4813 if (temp1)
4814 delete arg1;
4815 }
4816 {
4817 if (temp2)
4818 delete arg2;
4819 }
4820 {
4821 if (temp3)
4822 delete arg3;
4823 }
4824 return resultobj;
4825 fail:
4826 {
4827 if (temp1)
4828 delete arg1;
4829 }
4830 {
4831 if (temp2)
4832 delete arg2;
4833 }
4834 {
4835 if (temp3)
4836 delete arg3;
4837 }
4838 return NULL;
4839 }
4840
4841
4842 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4843 PyObject *resultobj;
4844 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4845 wxString *arg1 = (wxString *) &arg1_defvalue ;
4846 wxString const &arg2_defvalue = wxPyEmptyString ;
4847 wxString *arg2 = (wxString *) &arg2_defvalue ;
4848 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4849 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4850 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4851 wxWindow *arg5 = (wxWindow *) NULL ;
4852 wxString result;
4853 bool temp1 = false ;
4854 bool temp2 = false ;
4855 wxPoint temp4 ;
4856 PyObject * obj0 = 0 ;
4857 PyObject * obj1 = 0 ;
4858 PyObject * obj2 = 0 ;
4859 PyObject * obj3 = 0 ;
4860 PyObject * obj4 = 0 ;
4861 char *kwnames[] = {
4862 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4863 };
4864
4865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4866 if (obj0) {
4867 {
4868 arg1 = wxString_in_helper(obj0);
4869 if (arg1 == NULL) SWIG_fail;
4870 temp1 = true;
4871 }
4872 }
4873 if (obj1) {
4874 {
4875 arg2 = wxString_in_helper(obj1);
4876 if (arg2 == NULL) SWIG_fail;
4877 temp2 = true;
4878 }
4879 }
4880 if (obj2) {
4881 {
4882 arg3 = (long)(SWIG_As_long(obj2));
4883 if (SWIG_arg_fail(3)) SWIG_fail;
4884 }
4885 }
4886 if (obj3) {
4887 {
4888 arg4 = &temp4;
4889 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4890 }
4891 }
4892 if (obj4) {
4893 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4894 if (SWIG_arg_fail(5)) SWIG_fail;
4895 }
4896 {
4897 if (!wxPyCheckForApp()) SWIG_fail;
4898 PyThreadState* __tstate = wxPyBeginAllowThreads();
4899 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4900
4901 wxPyEndAllowThreads(__tstate);
4902 if (PyErr_Occurred()) SWIG_fail;
4903 }
4904 {
4905 #if wxUSE_UNICODE
4906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4907 #else
4908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4909 #endif
4910 }
4911 {
4912 if (temp1)
4913 delete arg1;
4914 }
4915 {
4916 if (temp2)
4917 delete arg2;
4918 }
4919 return resultobj;
4920 fail:
4921 {
4922 if (temp1)
4923 delete arg1;
4924 }
4925 {
4926 if (temp2)
4927 delete arg2;
4928 }
4929 return NULL;
4930 }
4931
4932
4933 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4934 PyObject *resultobj;
4935 wxString *arg1 = 0 ;
4936 wxString const &arg2_defvalue = wxPyEmptyString ;
4937 wxString *arg2 = (wxString *) &arg2_defvalue ;
4938 wxString const &arg3_defvalue = wxPyEmptyString ;
4939 wxString *arg3 = (wxString *) &arg3_defvalue ;
4940 wxWindow *arg4 = (wxWindow *) NULL ;
4941 int arg5 = (int) -1 ;
4942 int arg6 = (int) -1 ;
4943 bool arg7 = (bool) true ;
4944 wxString result;
4945 bool temp1 = false ;
4946 bool temp2 = false ;
4947 bool temp3 = false ;
4948 PyObject * obj0 = 0 ;
4949 PyObject * obj1 = 0 ;
4950 PyObject * obj2 = 0 ;
4951 PyObject * obj3 = 0 ;
4952 PyObject * obj4 = 0 ;
4953 PyObject * obj5 = 0 ;
4954 PyObject * obj6 = 0 ;
4955 char *kwnames[] = {
4956 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4957 };
4958
4959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4960 {
4961 arg1 = wxString_in_helper(obj0);
4962 if (arg1 == NULL) SWIG_fail;
4963 temp1 = true;
4964 }
4965 if (obj1) {
4966 {
4967 arg2 = wxString_in_helper(obj1);
4968 if (arg2 == NULL) SWIG_fail;
4969 temp2 = true;
4970 }
4971 }
4972 if (obj2) {
4973 {
4974 arg3 = wxString_in_helper(obj2);
4975 if (arg3 == NULL) SWIG_fail;
4976 temp3 = true;
4977 }
4978 }
4979 if (obj3) {
4980 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4981 if (SWIG_arg_fail(4)) SWIG_fail;
4982 }
4983 if (obj4) {
4984 {
4985 arg5 = (int)(SWIG_As_int(obj4));
4986 if (SWIG_arg_fail(5)) SWIG_fail;
4987 }
4988 }
4989 if (obj5) {
4990 {
4991 arg6 = (int)(SWIG_As_int(obj5));
4992 if (SWIG_arg_fail(6)) SWIG_fail;
4993 }
4994 }
4995 if (obj6) {
4996 {
4997 arg7 = (bool)(SWIG_As_bool(obj6));
4998 if (SWIG_arg_fail(7)) SWIG_fail;
4999 }
5000 }
5001 {
5002 if (!wxPyCheckForApp()) SWIG_fail;
5003 PyThreadState* __tstate = wxPyBeginAllowThreads();
5004 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5005
5006 wxPyEndAllowThreads(__tstate);
5007 if (PyErr_Occurred()) SWIG_fail;
5008 }
5009 {
5010 #if wxUSE_UNICODE
5011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5012 #else
5013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5014 #endif
5015 }
5016 {
5017 if (temp1)
5018 delete arg1;
5019 }
5020 {
5021 if (temp2)
5022 delete arg2;
5023 }
5024 {
5025 if (temp3)
5026 delete arg3;
5027 }
5028 return resultobj;
5029 fail:
5030 {
5031 if (temp1)
5032 delete arg1;
5033 }
5034 {
5035 if (temp2)
5036 delete arg2;
5037 }
5038 {
5039 if (temp3)
5040 delete arg3;
5041 }
5042 return NULL;
5043 }
5044
5045
5046 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5047 PyObject *resultobj;
5048 wxString *arg1 = 0 ;
5049 wxString const &arg2_defvalue = wxPyEmptyString ;
5050 wxString *arg2 = (wxString *) &arg2_defvalue ;
5051 wxString const &arg3_defvalue = wxPyEmptyString ;
5052 wxString *arg3 = (wxString *) &arg3_defvalue ;
5053 wxWindow *arg4 = (wxWindow *) NULL ;
5054 wxString result;
5055 bool temp1 = false ;
5056 bool temp2 = false ;
5057 bool temp3 = false ;
5058 PyObject * obj0 = 0 ;
5059 PyObject * obj1 = 0 ;
5060 PyObject * obj2 = 0 ;
5061 PyObject * obj3 = 0 ;
5062 char *kwnames[] = {
5063 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5064 };
5065
5066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5067 {
5068 arg1 = wxString_in_helper(obj0);
5069 if (arg1 == NULL) SWIG_fail;
5070 temp1 = true;
5071 }
5072 if (obj1) {
5073 {
5074 arg2 = wxString_in_helper(obj1);
5075 if (arg2 == NULL) SWIG_fail;
5076 temp2 = true;
5077 }
5078 }
5079 if (obj2) {
5080 {
5081 arg3 = wxString_in_helper(obj2);
5082 if (arg3 == NULL) SWIG_fail;
5083 temp3 = true;
5084 }
5085 }
5086 if (obj3) {
5087 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5088 if (SWIG_arg_fail(4)) SWIG_fail;
5089 }
5090 {
5091 if (!wxPyCheckForApp()) SWIG_fail;
5092 PyThreadState* __tstate = wxPyBeginAllowThreads();
5093 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5094
5095 wxPyEndAllowThreads(__tstate);
5096 if (PyErr_Occurred()) SWIG_fail;
5097 }
5098 {
5099 #if wxUSE_UNICODE
5100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5101 #else
5102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5103 #endif
5104 }
5105 {
5106 if (temp1)
5107 delete arg1;
5108 }
5109 {
5110 if (temp2)
5111 delete arg2;
5112 }
5113 {
5114 if (temp3)
5115 delete arg3;
5116 }
5117 return resultobj;
5118 fail:
5119 {
5120 if (temp1)
5121 delete arg1;
5122 }
5123 {
5124 if (temp2)
5125 delete arg2;
5126 }
5127 {
5128 if (temp3)
5129 delete arg3;
5130 }
5131 return NULL;
5132 }
5133
5134
5135 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5136 PyObject *resultobj;
5137 wxString *arg1 = 0 ;
5138 wxString *arg2 = 0 ;
5139 int arg3 ;
5140 wxString *arg4 = (wxString *) 0 ;
5141 wxWindow *arg5 = (wxWindow *) NULL ;
5142 int arg6 = (int) -1 ;
5143 int arg7 = (int) -1 ;
5144 bool arg8 = (bool) true ;
5145 int arg9 = (int) 150 ;
5146 int arg10 = (int) 200 ;
5147 wxString result;
5148 bool temp1 = false ;
5149 bool temp2 = false ;
5150 PyObject * obj0 = 0 ;
5151 PyObject * obj1 = 0 ;
5152 PyObject * obj2 = 0 ;
5153 PyObject * obj3 = 0 ;
5154 PyObject * obj4 = 0 ;
5155 PyObject * obj5 = 0 ;
5156 PyObject * obj6 = 0 ;
5157 PyObject * obj7 = 0 ;
5158 PyObject * obj8 = 0 ;
5159 char *kwnames[] = {
5160 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5161 };
5162
5163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5164 {
5165 arg1 = wxString_in_helper(obj0);
5166 if (arg1 == NULL) SWIG_fail;
5167 temp1 = true;
5168 }
5169 {
5170 arg2 = wxString_in_helper(obj1);
5171 if (arg2 == NULL) SWIG_fail;
5172 temp2 = true;
5173 }
5174 {
5175 arg3 = PyList_Size(obj2);
5176 arg4 = wxString_LIST_helper(obj2);
5177 if (arg4 == NULL) SWIG_fail;
5178 }
5179 if (obj3) {
5180 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5181 if (SWIG_arg_fail(5)) SWIG_fail;
5182 }
5183 if (obj4) {
5184 {
5185 arg6 = (int)(SWIG_As_int(obj4));
5186 if (SWIG_arg_fail(6)) SWIG_fail;
5187 }
5188 }
5189 if (obj5) {
5190 {
5191 arg7 = (int)(SWIG_As_int(obj5));
5192 if (SWIG_arg_fail(7)) SWIG_fail;
5193 }
5194 }
5195 if (obj6) {
5196 {
5197 arg8 = (bool)(SWIG_As_bool(obj6));
5198 if (SWIG_arg_fail(8)) SWIG_fail;
5199 }
5200 }
5201 if (obj7) {
5202 {
5203 arg9 = (int)(SWIG_As_int(obj7));
5204 if (SWIG_arg_fail(9)) SWIG_fail;
5205 }
5206 }
5207 if (obj8) {
5208 {
5209 arg10 = (int)(SWIG_As_int(obj8));
5210 if (SWIG_arg_fail(10)) SWIG_fail;
5211 }
5212 }
5213 {
5214 if (!wxPyCheckForApp()) SWIG_fail;
5215 PyThreadState* __tstate = wxPyBeginAllowThreads();
5216 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5217
5218 wxPyEndAllowThreads(__tstate);
5219 if (PyErr_Occurred()) SWIG_fail;
5220 }
5221 {
5222 #if wxUSE_UNICODE
5223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5224 #else
5225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5226 #endif
5227 }
5228 {
5229 if (temp1)
5230 delete arg1;
5231 }
5232 {
5233 if (temp2)
5234 delete arg2;
5235 }
5236 {
5237 if (arg4) delete [] arg4;
5238 }
5239 return resultobj;
5240 fail:
5241 {
5242 if (temp1)
5243 delete arg1;
5244 }
5245 {
5246 if (temp2)
5247 delete arg2;
5248 }
5249 {
5250 if (arg4) delete [] arg4;
5251 }
5252 return NULL;
5253 }
5254
5255
5256 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5257 PyObject *resultobj;
5258 wxString *arg1 = 0 ;
5259 wxString *arg2 = 0 ;
5260 int arg3 ;
5261 wxString *arg4 = (wxString *) 0 ;
5262 wxWindow *arg5 = (wxWindow *) NULL ;
5263 int arg6 = (int) -1 ;
5264 int arg7 = (int) -1 ;
5265 bool arg8 = (bool) true ;
5266 int arg9 = (int) 150 ;
5267 int arg10 = (int) 200 ;
5268 int result;
5269 bool temp1 = false ;
5270 bool temp2 = false ;
5271 PyObject * obj0 = 0 ;
5272 PyObject * obj1 = 0 ;
5273 PyObject * obj2 = 0 ;
5274 PyObject * obj3 = 0 ;
5275 PyObject * obj4 = 0 ;
5276 PyObject * obj5 = 0 ;
5277 PyObject * obj6 = 0 ;
5278 PyObject * obj7 = 0 ;
5279 PyObject * obj8 = 0 ;
5280 char *kwnames[] = {
5281 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5282 };
5283
5284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5285 {
5286 arg1 = wxString_in_helper(obj0);
5287 if (arg1 == NULL) SWIG_fail;
5288 temp1 = true;
5289 }
5290 {
5291 arg2 = wxString_in_helper(obj1);
5292 if (arg2 == NULL) SWIG_fail;
5293 temp2 = true;
5294 }
5295 {
5296 arg3 = PyList_Size(obj2);
5297 arg4 = wxString_LIST_helper(obj2);
5298 if (arg4 == NULL) SWIG_fail;
5299 }
5300 if (obj3) {
5301 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5302 if (SWIG_arg_fail(5)) SWIG_fail;
5303 }
5304 if (obj4) {
5305 {
5306 arg6 = (int)(SWIG_As_int(obj4));
5307 if (SWIG_arg_fail(6)) SWIG_fail;
5308 }
5309 }
5310 if (obj5) {
5311 {
5312 arg7 = (int)(SWIG_As_int(obj5));
5313 if (SWIG_arg_fail(7)) SWIG_fail;
5314 }
5315 }
5316 if (obj6) {
5317 {
5318 arg8 = (bool)(SWIG_As_bool(obj6));
5319 if (SWIG_arg_fail(8)) SWIG_fail;
5320 }
5321 }
5322 if (obj7) {
5323 {
5324 arg9 = (int)(SWIG_As_int(obj7));
5325 if (SWIG_arg_fail(9)) SWIG_fail;
5326 }
5327 }
5328 if (obj8) {
5329 {
5330 arg10 = (int)(SWIG_As_int(obj8));
5331 if (SWIG_arg_fail(10)) SWIG_fail;
5332 }
5333 }
5334 {
5335 if (!wxPyCheckForApp()) SWIG_fail;
5336 PyThreadState* __tstate = wxPyBeginAllowThreads();
5337 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5338
5339 wxPyEndAllowThreads(__tstate);
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 {
5343 resultobj = SWIG_From_int((int)(result));
5344 }
5345 {
5346 if (temp1)
5347 delete arg1;
5348 }
5349 {
5350 if (temp2)
5351 delete arg2;
5352 }
5353 {
5354 if (arg4) delete [] arg4;
5355 }
5356 return resultobj;
5357 fail:
5358 {
5359 if (temp1)
5360 delete arg1;
5361 }
5362 {
5363 if (temp2)
5364 delete arg2;
5365 }
5366 {
5367 if (arg4) delete [] arg4;
5368 }
5369 return NULL;
5370 }
5371
5372
5373 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5374 PyObject *resultobj;
5375 wxString *arg1 = 0 ;
5376 wxString const &arg2_defvalue = wxPyEmptyString ;
5377 wxString *arg2 = (wxString *) &arg2_defvalue ;
5378 int arg3 = (int) wxOK|wxCENTRE ;
5379 wxWindow *arg4 = (wxWindow *) NULL ;
5380 int arg5 = (int) -1 ;
5381 int arg6 = (int) -1 ;
5382 int result;
5383 bool temp1 = false ;
5384 bool temp2 = false ;
5385 PyObject * obj0 = 0 ;
5386 PyObject * obj1 = 0 ;
5387 PyObject * obj2 = 0 ;
5388 PyObject * obj3 = 0 ;
5389 PyObject * obj4 = 0 ;
5390 PyObject * obj5 = 0 ;
5391 char *kwnames[] = {
5392 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5393 };
5394
5395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5396 {
5397 arg1 = wxString_in_helper(obj0);
5398 if (arg1 == NULL) SWIG_fail;
5399 temp1 = true;
5400 }
5401 if (obj1) {
5402 {
5403 arg2 = wxString_in_helper(obj1);
5404 if (arg2 == NULL) SWIG_fail;
5405 temp2 = true;
5406 }
5407 }
5408 if (obj2) {
5409 {
5410 arg3 = (int)(SWIG_As_int(obj2));
5411 if (SWIG_arg_fail(3)) SWIG_fail;
5412 }
5413 }
5414 if (obj3) {
5415 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5416 if (SWIG_arg_fail(4)) SWIG_fail;
5417 }
5418 if (obj4) {
5419 {
5420 arg5 = (int)(SWIG_As_int(obj4));
5421 if (SWIG_arg_fail(5)) SWIG_fail;
5422 }
5423 }
5424 if (obj5) {
5425 {
5426 arg6 = (int)(SWIG_As_int(obj5));
5427 if (SWIG_arg_fail(6)) SWIG_fail;
5428 }
5429 }
5430 {
5431 if (!wxPyCheckForApp()) SWIG_fail;
5432 PyThreadState* __tstate = wxPyBeginAllowThreads();
5433 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5434
5435 wxPyEndAllowThreads(__tstate);
5436 if (PyErr_Occurred()) SWIG_fail;
5437 }
5438 {
5439 resultobj = SWIG_From_int((int)(result));
5440 }
5441 {
5442 if (temp1)
5443 delete arg1;
5444 }
5445 {
5446 if (temp2)
5447 delete arg2;
5448 }
5449 return resultobj;
5450 fail:
5451 {
5452 if (temp1)
5453 delete arg1;
5454 }
5455 {
5456 if (temp2)
5457 delete arg2;
5458 }
5459 return NULL;
5460 }
5461
5462
5463 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5464 PyObject *resultobj;
5465 wxString *arg1 = 0 ;
5466 wxString *arg2 = 0 ;
5467 wxString *arg3 = 0 ;
5468 long arg4 ;
5469 long arg5 = (long) 0 ;
5470 long arg6 = (long) 100 ;
5471 wxWindow *arg7 = (wxWindow *) NULL ;
5472 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5473 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5474 long result;
5475 bool temp1 = false ;
5476 bool temp2 = false ;
5477 bool temp3 = false ;
5478 wxPoint temp8 ;
5479 PyObject * obj0 = 0 ;
5480 PyObject * obj1 = 0 ;
5481 PyObject * obj2 = 0 ;
5482 PyObject * obj3 = 0 ;
5483 PyObject * obj4 = 0 ;
5484 PyObject * obj5 = 0 ;
5485 PyObject * obj6 = 0 ;
5486 PyObject * obj7 = 0 ;
5487 char *kwnames[] = {
5488 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5489 };
5490
5491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5492 {
5493 arg1 = wxString_in_helper(obj0);
5494 if (arg1 == NULL) SWIG_fail;
5495 temp1 = true;
5496 }
5497 {
5498 arg2 = wxString_in_helper(obj1);
5499 if (arg2 == NULL) SWIG_fail;
5500 temp2 = true;
5501 }
5502 {
5503 arg3 = wxString_in_helper(obj2);
5504 if (arg3 == NULL) SWIG_fail;
5505 temp3 = true;
5506 }
5507 {
5508 arg4 = (long)(SWIG_As_long(obj3));
5509 if (SWIG_arg_fail(4)) SWIG_fail;
5510 }
5511 if (obj4) {
5512 {
5513 arg5 = (long)(SWIG_As_long(obj4));
5514 if (SWIG_arg_fail(5)) SWIG_fail;
5515 }
5516 }
5517 if (obj5) {
5518 {
5519 arg6 = (long)(SWIG_As_long(obj5));
5520 if (SWIG_arg_fail(6)) SWIG_fail;
5521 }
5522 }
5523 if (obj6) {
5524 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5525 if (SWIG_arg_fail(7)) SWIG_fail;
5526 }
5527 if (obj7) {
5528 {
5529 arg8 = &temp8;
5530 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5531 }
5532 }
5533 {
5534 if (!wxPyCheckForApp()) SWIG_fail;
5535 PyThreadState* __tstate = wxPyBeginAllowThreads();
5536 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5537
5538 wxPyEndAllowThreads(__tstate);
5539 if (PyErr_Occurred()) SWIG_fail;
5540 }
5541 {
5542 resultobj = SWIG_From_long((long)(result));
5543 }
5544 {
5545 if (temp1)
5546 delete arg1;
5547 }
5548 {
5549 if (temp2)
5550 delete arg2;
5551 }
5552 {
5553 if (temp3)
5554 delete arg3;
5555 }
5556 return resultobj;
5557 fail:
5558 {
5559 if (temp1)
5560 delete arg1;
5561 }
5562 {
5563 if (temp2)
5564 delete arg2;
5565 }
5566 {
5567 if (temp3)
5568 delete arg3;
5569 }
5570 return NULL;
5571 }
5572
5573
5574 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5575 PyObject *resultobj;
5576 bool result;
5577 char *kwnames[] = {
5578 NULL
5579 };
5580
5581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5582 {
5583 if (!wxPyCheckForApp()) SWIG_fail;
5584 PyThreadState* __tstate = wxPyBeginAllowThreads();
5585 result = (bool)wxColourDisplay();
5586
5587 wxPyEndAllowThreads(__tstate);
5588 if (PyErr_Occurred()) SWIG_fail;
5589 }
5590 {
5591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5592 }
5593 return resultobj;
5594 fail:
5595 return NULL;
5596 }
5597
5598
5599 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5600 PyObject *resultobj;
5601 int result;
5602 char *kwnames[] = {
5603 NULL
5604 };
5605
5606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5607 {
5608 if (!wxPyCheckForApp()) SWIG_fail;
5609 PyThreadState* __tstate = wxPyBeginAllowThreads();
5610 result = (int)wxDisplayDepth();
5611
5612 wxPyEndAllowThreads(__tstate);
5613 if (PyErr_Occurred()) SWIG_fail;
5614 }
5615 {
5616 resultobj = SWIG_From_int((int)(result));
5617 }
5618 return resultobj;
5619 fail:
5620 return NULL;
5621 }
5622
5623
5624 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5625 PyObject *resultobj;
5626 int result;
5627 char *kwnames[] = {
5628 NULL
5629 };
5630
5631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5632 {
5633 if (!wxPyCheckForApp()) SWIG_fail;
5634 PyThreadState* __tstate = wxPyBeginAllowThreads();
5635 result = (int)wxGetDisplayDepth();
5636
5637 wxPyEndAllowThreads(__tstate);
5638 if (PyErr_Occurred()) SWIG_fail;
5639 }
5640 {
5641 resultobj = SWIG_From_int((int)(result));
5642 }
5643 return resultobj;
5644 fail:
5645 return NULL;
5646 }
5647
5648
5649 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5650 PyObject *resultobj;
5651 int *arg1 = (int *) 0 ;
5652 int *arg2 = (int *) 0 ;
5653 int temp1 ;
5654 int res1 = 0 ;
5655 int temp2 ;
5656 int res2 = 0 ;
5657 char *kwnames[] = {
5658 NULL
5659 };
5660
5661 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5662 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5664 {
5665 if (!wxPyCheckForApp()) SWIG_fail;
5666 PyThreadState* __tstate = wxPyBeginAllowThreads();
5667 wxDisplaySize(arg1,arg2);
5668
5669 wxPyEndAllowThreads(__tstate);
5670 if (PyErr_Occurred()) SWIG_fail;
5671 }
5672 Py_INCREF(Py_None); resultobj = Py_None;
5673 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5674 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5675 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5676 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5677 return resultobj;
5678 fail:
5679 return NULL;
5680 }
5681
5682
5683 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5684 PyObject *resultobj;
5685 wxSize result;
5686 char *kwnames[] = {
5687 NULL
5688 };
5689
5690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5691 {
5692 if (!wxPyCheckForApp()) SWIG_fail;
5693 PyThreadState* __tstate = wxPyBeginAllowThreads();
5694 result = wxGetDisplaySize();
5695
5696 wxPyEndAllowThreads(__tstate);
5697 if (PyErr_Occurred()) SWIG_fail;
5698 }
5699 {
5700 wxSize * resultptr;
5701 resultptr = new wxSize((wxSize &)(result));
5702 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5703 }
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj;
5712 int *arg1 = (int *) 0 ;
5713 int *arg2 = (int *) 0 ;
5714 int temp1 ;
5715 int res1 = 0 ;
5716 int temp2 ;
5717 int res2 = 0 ;
5718 char *kwnames[] = {
5719 NULL
5720 };
5721
5722 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5723 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5725 {
5726 if (!wxPyCheckForApp()) SWIG_fail;
5727 PyThreadState* __tstate = wxPyBeginAllowThreads();
5728 wxDisplaySizeMM(arg1,arg2);
5729
5730 wxPyEndAllowThreads(__tstate);
5731 if (PyErr_Occurred()) SWIG_fail;
5732 }
5733 Py_INCREF(Py_None); resultobj = Py_None;
5734 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5735 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5736 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5737 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5738 return resultobj;
5739 fail:
5740 return NULL;
5741 }
5742
5743
5744 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5745 PyObject *resultobj;
5746 wxSize result;
5747 char *kwnames[] = {
5748 NULL
5749 };
5750
5751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5752 {
5753 if (!wxPyCheckForApp()) SWIG_fail;
5754 PyThreadState* __tstate = wxPyBeginAllowThreads();
5755 result = wxGetDisplaySizeMM();
5756
5757 wxPyEndAllowThreads(__tstate);
5758 if (PyErr_Occurred()) SWIG_fail;
5759 }
5760 {
5761 wxSize * resultptr;
5762 resultptr = new wxSize((wxSize &)(result));
5763 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5764 }
5765 return resultobj;
5766 fail:
5767 return NULL;
5768 }
5769
5770
5771 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5772 PyObject *resultobj;
5773 int *arg1 = (int *) 0 ;
5774 int *arg2 = (int *) 0 ;
5775 int *arg3 = (int *) 0 ;
5776 int *arg4 = (int *) 0 ;
5777 int temp1 ;
5778 int res1 = 0 ;
5779 int temp2 ;
5780 int res2 = 0 ;
5781 int temp3 ;
5782 int res3 = 0 ;
5783 int temp4 ;
5784 int res4 = 0 ;
5785 char *kwnames[] = {
5786 NULL
5787 };
5788
5789 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5790 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5791 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5792 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5794 {
5795 if (!wxPyCheckForApp()) SWIG_fail;
5796 PyThreadState* __tstate = wxPyBeginAllowThreads();
5797 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5798
5799 wxPyEndAllowThreads(__tstate);
5800 if (PyErr_Occurred()) SWIG_fail;
5801 }
5802 Py_INCREF(Py_None); resultobj = Py_None;
5803 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5804 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5805 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5806 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5807 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5808 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5809 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5810 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5811 return resultobj;
5812 fail:
5813 return NULL;
5814 }
5815
5816
5817 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5818 PyObject *resultobj;
5819 wxRect result;
5820 char *kwnames[] = {
5821 NULL
5822 };
5823
5824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5825 {
5826 if (!wxPyCheckForApp()) SWIG_fail;
5827 PyThreadState* __tstate = wxPyBeginAllowThreads();
5828 result = wxGetClientDisplayRect();
5829
5830 wxPyEndAllowThreads(__tstate);
5831 if (PyErr_Occurred()) SWIG_fail;
5832 }
5833 {
5834 wxRect * resultptr;
5835 resultptr = new wxRect((wxRect &)(result));
5836 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5837 }
5838 return resultobj;
5839 fail:
5840 return NULL;
5841 }
5842
5843
5844 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5845 PyObject *resultobj;
5846 wxCursor *arg1 = 0 ;
5847 PyObject * obj0 = 0 ;
5848 char *kwnames[] = {
5849 (char *) "cursor", NULL
5850 };
5851
5852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5853 {
5854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5855 if (SWIG_arg_fail(1)) SWIG_fail;
5856 if (arg1 == NULL) {
5857 SWIG_null_ref("wxCursor");
5858 }
5859 if (SWIG_arg_fail(1)) SWIG_fail;
5860 }
5861 {
5862 if (!wxPyCheckForApp()) SWIG_fail;
5863 PyThreadState* __tstate = wxPyBeginAllowThreads();
5864 wxSetCursor(*arg1);
5865
5866 wxPyEndAllowThreads(__tstate);
5867 if (PyErr_Occurred()) SWIG_fail;
5868 }
5869 Py_INCREF(Py_None); resultobj = Py_None;
5870 return resultobj;
5871 fail:
5872 return NULL;
5873 }
5874
5875
5876 static PyObject *_wrap_GetXDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5877 PyObject *resultobj;
5878 void *result;
5879 char *kwnames[] = {
5880 NULL
5881 };
5882
5883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetXDisplay",kwnames)) goto fail;
5884 {
5885 if (!wxPyCheckForApp()) SWIG_fail;
5886 PyThreadState* __tstate = wxPyBeginAllowThreads();
5887 result = (void *)wxGetXDisplay();
5888
5889 wxPyEndAllowThreads(__tstate);
5890 if (PyErr_Occurred()) SWIG_fail;
5891 }
5892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
5893 return resultobj;
5894 fail:
5895 return NULL;
5896 }
5897
5898
5899 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5900 PyObject *resultobj;
5901 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5902 PyObject * obj0 = 0 ;
5903 char *kwnames[] = {
5904 (char *) "cursor", NULL
5905 };
5906
5907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5908 if (obj0) {
5909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5910 if (SWIG_arg_fail(1)) SWIG_fail;
5911 }
5912 {
5913 if (!wxPyCheckForApp()) SWIG_fail;
5914 PyThreadState* __tstate = wxPyBeginAllowThreads();
5915 wxBeginBusyCursor(arg1);
5916
5917 wxPyEndAllowThreads(__tstate);
5918 if (PyErr_Occurred()) SWIG_fail;
5919 }
5920 Py_INCREF(Py_None); resultobj = Py_None;
5921 return resultobj;
5922 fail:
5923 return NULL;
5924 }
5925
5926
5927 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5928 PyObject *resultobj;
5929 wxWindow *result;
5930 char *kwnames[] = {
5931 NULL
5932 };
5933
5934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5935 {
5936 if (!wxPyCheckForApp()) SWIG_fail;
5937 PyThreadState* __tstate = wxPyBeginAllowThreads();
5938 result = (wxWindow *)wxGetActiveWindow();
5939
5940 wxPyEndAllowThreads(__tstate);
5941 if (PyErr_Occurred()) SWIG_fail;
5942 }
5943 {
5944 resultobj = wxPyMake_wxObject(result, 0);
5945 }
5946 return resultobj;
5947 fail:
5948 return NULL;
5949 }
5950
5951
5952 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5953 PyObject *resultobj;
5954 wxPoint *arg1 = 0 ;
5955 wxWindow *result;
5956 wxPoint temp1 ;
5957 PyObject * obj0 = 0 ;
5958 char *kwnames[] = {
5959 (char *) "pt", NULL
5960 };
5961
5962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5963 {
5964 arg1 = &temp1;
5965 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5966 }
5967 {
5968 if (!wxPyCheckForApp()) SWIG_fail;
5969 PyThreadState* __tstate = wxPyBeginAllowThreads();
5970 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5971
5972 wxPyEndAllowThreads(__tstate);
5973 if (PyErr_Occurred()) SWIG_fail;
5974 }
5975 {
5976 resultobj = wxPyMake_wxObject(result, 0);
5977 }
5978 return resultobj;
5979 fail:
5980 return NULL;
5981 }
5982
5983
5984 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5985 PyObject *resultobj;
5986 wxPoint *arg1 = 0 ;
5987 wxWindow *result;
5988 wxPoint temp1 ;
5989 PyObject * obj0 = 0 ;
5990 char *kwnames[] = {
5991 (char *) "pt", NULL
5992 };
5993
5994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5995 {
5996 arg1 = &temp1;
5997 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5998 }
5999 {
6000 if (!wxPyCheckForApp()) SWIG_fail;
6001 PyThreadState* __tstate = wxPyBeginAllowThreads();
6002 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6003
6004 wxPyEndAllowThreads(__tstate);
6005 if (PyErr_Occurred()) SWIG_fail;
6006 }
6007 {
6008 resultobj = wxPyMake_wxObject(result, 0);
6009 }
6010 return resultobj;
6011 fail:
6012 return NULL;
6013 }
6014
6015
6016 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
6017 PyObject *resultobj;
6018 wxWindow *arg1 = (wxWindow *) 0 ;
6019 wxWindow *result;
6020 PyObject * obj0 = 0 ;
6021 char *kwnames[] = {
6022 (char *) "win", NULL
6023 };
6024
6025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
6026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6027 if (SWIG_arg_fail(1)) SWIG_fail;
6028 {
6029 if (!wxPyCheckForApp()) SWIG_fail;
6030 PyThreadState* __tstate = wxPyBeginAllowThreads();
6031 result = (wxWindow *)wxGetTopLevelParent(arg1);
6032
6033 wxPyEndAllowThreads(__tstate);
6034 if (PyErr_Occurred()) SWIG_fail;
6035 }
6036 {
6037 resultobj = wxPyMake_wxObject(result, 0);
6038 }
6039 return resultobj;
6040 fail:
6041 return NULL;
6042 }
6043
6044
6045 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6046 PyObject *resultobj;
6047 wxString *arg1 = 0 ;
6048 bool result;
6049 bool temp1 = false ;
6050 PyObject * obj0 = 0 ;
6051 char *kwnames[] = {
6052 (char *) "url", NULL
6053 };
6054
6055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6056 {
6057 arg1 = wxString_in_helper(obj0);
6058 if (arg1 == NULL) SWIG_fail;
6059 temp1 = true;
6060 }
6061 {
6062 PyThreadState* __tstate = wxPyBeginAllowThreads();
6063 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6064
6065 wxPyEndAllowThreads(__tstate);
6066 if (PyErr_Occurred()) SWIG_fail;
6067 }
6068 {
6069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6070 }
6071 {
6072 if (temp1)
6073 delete arg1;
6074 }
6075 return resultobj;
6076 fail:
6077 {
6078 if (temp1)
6079 delete arg1;
6080 }
6081 return NULL;
6082 }
6083
6084
6085 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6086 PyObject *resultobj;
6087 wxKeyCode arg1 ;
6088 bool result;
6089 PyObject * obj0 = 0 ;
6090 char *kwnames[] = {
6091 (char *) "key", NULL
6092 };
6093
6094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6095 {
6096 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6097 if (SWIG_arg_fail(1)) SWIG_fail;
6098 }
6099 {
6100 if (!wxPyCheckForApp()) SWIG_fail;
6101 PyThreadState* __tstate = wxPyBeginAllowThreads();
6102 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6103
6104 wxPyEndAllowThreads(__tstate);
6105 if (PyErr_Occurred()) SWIG_fail;
6106 }
6107 {
6108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6109 }
6110 return resultobj;
6111 fail:
6112 return NULL;
6113 }
6114
6115
6116 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6117 PyObject *resultobj;
6118 char *kwnames[] = {
6119 NULL
6120 };
6121
6122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6123 {
6124 if (!wxPyCheckForApp()) SWIG_fail;
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 wxWakeUpMainThread();
6127
6128 wxPyEndAllowThreads(__tstate);
6129 if (PyErr_Occurred()) SWIG_fail;
6130 }
6131 Py_INCREF(Py_None); resultobj = Py_None;
6132 return resultobj;
6133 fail:
6134 return NULL;
6135 }
6136
6137
6138 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6139 PyObject *resultobj;
6140 char *kwnames[] = {
6141 NULL
6142 };
6143
6144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6145 {
6146 if (!wxPyCheckForApp()) SWIG_fail;
6147 PyThreadState* __tstate = wxPyBeginAllowThreads();
6148 wxMutexGuiEnter();
6149
6150 wxPyEndAllowThreads(__tstate);
6151 if (PyErr_Occurred()) SWIG_fail;
6152 }
6153 Py_INCREF(Py_None); resultobj = Py_None;
6154 return resultobj;
6155 fail:
6156 return NULL;
6157 }
6158
6159
6160 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6161 PyObject *resultobj;
6162 char *kwnames[] = {
6163 NULL
6164 };
6165
6166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6167 {
6168 if (!wxPyCheckForApp()) SWIG_fail;
6169 PyThreadState* __tstate = wxPyBeginAllowThreads();
6170 wxMutexGuiLeave();
6171
6172 wxPyEndAllowThreads(__tstate);
6173 if (PyErr_Occurred()) SWIG_fail;
6174 }
6175 Py_INCREF(Py_None); resultobj = Py_None;
6176 return resultobj;
6177 fail:
6178 return NULL;
6179 }
6180
6181
6182 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6183 PyObject *resultobj;
6184 wxMutexGuiLocker *result;
6185 char *kwnames[] = {
6186 NULL
6187 };
6188
6189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6190 {
6191 if (!wxPyCheckForApp()) SWIG_fail;
6192 PyThreadState* __tstate = wxPyBeginAllowThreads();
6193 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6194
6195 wxPyEndAllowThreads(__tstate);
6196 if (PyErr_Occurred()) SWIG_fail;
6197 }
6198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6199 return resultobj;
6200 fail:
6201 return NULL;
6202 }
6203
6204
6205 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6206 PyObject *resultobj;
6207 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6208 PyObject * obj0 = 0 ;
6209 char *kwnames[] = {
6210 (char *) "self", NULL
6211 };
6212
6213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6215 if (SWIG_arg_fail(1)) SWIG_fail;
6216 {
6217 PyThreadState* __tstate = wxPyBeginAllowThreads();
6218 delete arg1;
6219
6220 wxPyEndAllowThreads(__tstate);
6221 if (PyErr_Occurred()) SWIG_fail;
6222 }
6223 Py_INCREF(Py_None); resultobj = Py_None;
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6231 PyObject *obj;
6232 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6233 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6234 Py_INCREF(obj);
6235 return Py_BuildValue((char *)"");
6236 }
6237 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6238 PyObject *resultobj;
6239 bool result;
6240 char *kwnames[] = {
6241 NULL
6242 };
6243
6244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6245 {
6246 PyThreadState* __tstate = wxPyBeginAllowThreads();
6247 result = (bool)wxThread_IsMain();
6248
6249 wxPyEndAllowThreads(__tstate);
6250 if (PyErr_Occurred()) SWIG_fail;
6251 }
6252 {
6253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6254 }
6255 return resultobj;
6256 fail:
6257 return NULL;
6258 }
6259
6260
6261 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6262 PyObject *resultobj;
6263 wxString *arg1 = 0 ;
6264 wxToolTip *result;
6265 bool temp1 = false ;
6266 PyObject * obj0 = 0 ;
6267 char *kwnames[] = {
6268 (char *) "tip", NULL
6269 };
6270
6271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6272 {
6273 arg1 = wxString_in_helper(obj0);
6274 if (arg1 == NULL) SWIG_fail;
6275 temp1 = true;
6276 }
6277 {
6278 if (!wxPyCheckForApp()) SWIG_fail;
6279 PyThreadState* __tstate = wxPyBeginAllowThreads();
6280 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6281
6282 wxPyEndAllowThreads(__tstate);
6283 if (PyErr_Occurred()) SWIG_fail;
6284 }
6285 {
6286 resultobj = wxPyMake_wxObject(result, 1);
6287 }
6288 {
6289 if (temp1)
6290 delete arg1;
6291 }
6292 return resultobj;
6293 fail:
6294 {
6295 if (temp1)
6296 delete arg1;
6297 }
6298 return NULL;
6299 }
6300
6301
6302 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj;
6304 wxToolTip *arg1 = (wxToolTip *) 0 ;
6305 wxString *arg2 = 0 ;
6306 bool temp2 = false ;
6307 PyObject * obj0 = 0 ;
6308 PyObject * obj1 = 0 ;
6309 char *kwnames[] = {
6310 (char *) "self",(char *) "tip", NULL
6311 };
6312
6313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6315 if (SWIG_arg_fail(1)) SWIG_fail;
6316 {
6317 arg2 = wxString_in_helper(obj1);
6318 if (arg2 == NULL) SWIG_fail;
6319 temp2 = true;
6320 }
6321 {
6322 PyThreadState* __tstate = wxPyBeginAllowThreads();
6323 (arg1)->SetTip((wxString const &)*arg2);
6324
6325 wxPyEndAllowThreads(__tstate);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 Py_INCREF(Py_None); resultobj = Py_None;
6329 {
6330 if (temp2)
6331 delete arg2;
6332 }
6333 return resultobj;
6334 fail:
6335 {
6336 if (temp2)
6337 delete arg2;
6338 }
6339 return NULL;
6340 }
6341
6342
6343 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6344 PyObject *resultobj;
6345 wxToolTip *arg1 = (wxToolTip *) 0 ;
6346 wxString result;
6347 PyObject * obj0 = 0 ;
6348 char *kwnames[] = {
6349 (char *) "self", NULL
6350 };
6351
6352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6354 if (SWIG_arg_fail(1)) SWIG_fail;
6355 {
6356 PyThreadState* __tstate = wxPyBeginAllowThreads();
6357 result = (arg1)->GetTip();
6358
6359 wxPyEndAllowThreads(__tstate);
6360 if (PyErr_Occurred()) SWIG_fail;
6361 }
6362 {
6363 #if wxUSE_UNICODE
6364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6365 #else
6366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6367 #endif
6368 }
6369 return resultobj;
6370 fail:
6371 return NULL;
6372 }
6373
6374
6375 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6376 PyObject *resultobj;
6377 wxToolTip *arg1 = (wxToolTip *) 0 ;
6378 wxWindow *result;
6379 PyObject * obj0 = 0 ;
6380 char *kwnames[] = {
6381 (char *) "self", NULL
6382 };
6383
6384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6386 if (SWIG_arg_fail(1)) SWIG_fail;
6387 {
6388 PyThreadState* __tstate = wxPyBeginAllowThreads();
6389 result = (wxWindow *)(arg1)->GetWindow();
6390
6391 wxPyEndAllowThreads(__tstate);
6392 if (PyErr_Occurred()) SWIG_fail;
6393 }
6394 {
6395 resultobj = wxPyMake_wxObject(result, 0);
6396 }
6397 return resultobj;
6398 fail:
6399 return NULL;
6400 }
6401
6402
6403 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6404 PyObject *resultobj;
6405 bool arg1 ;
6406 PyObject * obj0 = 0 ;
6407 char *kwnames[] = {
6408 (char *) "flag", NULL
6409 };
6410
6411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6412 {
6413 arg1 = (bool)(SWIG_As_bool(obj0));
6414 if (SWIG_arg_fail(1)) SWIG_fail;
6415 }
6416 {
6417 PyThreadState* __tstate = wxPyBeginAllowThreads();
6418 wxToolTip::Enable(arg1);
6419
6420 wxPyEndAllowThreads(__tstate);
6421 if (PyErr_Occurred()) SWIG_fail;
6422 }
6423 Py_INCREF(Py_None); resultobj = Py_None;
6424 return resultobj;
6425 fail:
6426 return NULL;
6427 }
6428
6429
6430 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6431 PyObject *resultobj;
6432 long arg1 ;
6433 PyObject * obj0 = 0 ;
6434 char *kwnames[] = {
6435 (char *) "milliseconds", NULL
6436 };
6437
6438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6439 {
6440 arg1 = (long)(SWIG_As_long(obj0));
6441 if (SWIG_arg_fail(1)) SWIG_fail;
6442 }
6443 {
6444 PyThreadState* __tstate = wxPyBeginAllowThreads();
6445 wxToolTip::SetDelay(arg1);
6446
6447 wxPyEndAllowThreads(__tstate);
6448 if (PyErr_Occurred()) SWIG_fail;
6449 }
6450 Py_INCREF(Py_None); resultobj = Py_None;
6451 return resultobj;
6452 fail:
6453 return NULL;
6454 }
6455
6456
6457 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6458 PyObject *obj;
6459 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6460 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6461 Py_INCREF(obj);
6462 return Py_BuildValue((char *)"");
6463 }
6464 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6465 PyObject *resultobj;
6466 wxWindow *arg1 = (wxWindow *) 0 ;
6467 wxSize *arg2 = 0 ;
6468 wxCaret *result;
6469 wxSize temp2 ;
6470 PyObject * obj0 = 0 ;
6471 PyObject * obj1 = 0 ;
6472 char *kwnames[] = {
6473 (char *) "window",(char *) "size", NULL
6474 };
6475
6476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6478 if (SWIG_arg_fail(1)) SWIG_fail;
6479 {
6480 arg2 = &temp2;
6481 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6482 }
6483 {
6484 if (!wxPyCheckForApp()) SWIG_fail;
6485 PyThreadState* __tstate = wxPyBeginAllowThreads();
6486 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6487
6488 wxPyEndAllowThreads(__tstate);
6489 if (PyErr_Occurred()) SWIG_fail;
6490 }
6491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6492 return resultobj;
6493 fail:
6494 return NULL;
6495 }
6496
6497
6498 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6499 PyObject *resultobj;
6500 wxCaret *arg1 = (wxCaret *) 0 ;
6501 PyObject * obj0 = 0 ;
6502 char *kwnames[] = {
6503 (char *) "self", NULL
6504 };
6505
6506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6508 if (SWIG_arg_fail(1)) SWIG_fail;
6509 {
6510 PyThreadState* __tstate = wxPyBeginAllowThreads();
6511 wxCaret_Destroy(arg1);
6512
6513 wxPyEndAllowThreads(__tstate);
6514 if (PyErr_Occurred()) SWIG_fail;
6515 }
6516 Py_INCREF(Py_None); resultobj = Py_None;
6517 return resultobj;
6518 fail:
6519 return NULL;
6520 }
6521
6522
6523 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6524 PyObject *resultobj;
6525 wxCaret *arg1 = (wxCaret *) 0 ;
6526 bool result;
6527 PyObject * obj0 = 0 ;
6528 char *kwnames[] = {
6529 (char *) "self", NULL
6530 };
6531
6532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6534 if (SWIG_arg_fail(1)) SWIG_fail;
6535 {
6536 PyThreadState* __tstate = wxPyBeginAllowThreads();
6537 result = (bool)(arg1)->IsOk();
6538
6539 wxPyEndAllowThreads(__tstate);
6540 if (PyErr_Occurred()) SWIG_fail;
6541 }
6542 {
6543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6544 }
6545 return resultobj;
6546 fail:
6547 return NULL;
6548 }
6549
6550
6551 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6552 PyObject *resultobj;
6553 wxCaret *arg1 = (wxCaret *) 0 ;
6554 bool result;
6555 PyObject * obj0 = 0 ;
6556 char *kwnames[] = {
6557 (char *) "self", NULL
6558 };
6559
6560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6562 if (SWIG_arg_fail(1)) SWIG_fail;
6563 {
6564 PyThreadState* __tstate = wxPyBeginAllowThreads();
6565 result = (bool)(arg1)->IsVisible();
6566
6567 wxPyEndAllowThreads(__tstate);
6568 if (PyErr_Occurred()) SWIG_fail;
6569 }
6570 {
6571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6572 }
6573 return resultobj;
6574 fail:
6575 return NULL;
6576 }
6577
6578
6579 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6580 PyObject *resultobj;
6581 wxCaret *arg1 = (wxCaret *) 0 ;
6582 wxPoint result;
6583 PyObject * obj0 = 0 ;
6584 char *kwnames[] = {
6585 (char *) "self", NULL
6586 };
6587
6588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6590 if (SWIG_arg_fail(1)) SWIG_fail;
6591 {
6592 PyThreadState* __tstate = wxPyBeginAllowThreads();
6593 result = (arg1)->GetPosition();
6594
6595 wxPyEndAllowThreads(__tstate);
6596 if (PyErr_Occurred()) SWIG_fail;
6597 }
6598 {
6599 wxPoint * resultptr;
6600 resultptr = new wxPoint((wxPoint &)(result));
6601 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6602 }
6603 return resultobj;
6604 fail:
6605 return NULL;
6606 }
6607
6608
6609 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6610 PyObject *resultobj;
6611 wxCaret *arg1 = (wxCaret *) 0 ;
6612 int *arg2 = (int *) 0 ;
6613 int *arg3 = (int *) 0 ;
6614 int temp2 ;
6615 int res2 = 0 ;
6616 int temp3 ;
6617 int res3 = 0 ;
6618 PyObject * obj0 = 0 ;
6619 char *kwnames[] = {
6620 (char *) "self", NULL
6621 };
6622
6623 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6624 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6627 if (SWIG_arg_fail(1)) SWIG_fail;
6628 {
6629 PyThreadState* __tstate = wxPyBeginAllowThreads();
6630 (arg1)->GetPosition(arg2,arg3);
6631
6632 wxPyEndAllowThreads(__tstate);
6633 if (PyErr_Occurred()) SWIG_fail;
6634 }
6635 Py_INCREF(Py_None); resultobj = Py_None;
6636 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6637 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6638 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6639 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6640 return resultobj;
6641 fail:
6642 return NULL;
6643 }
6644
6645
6646 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6647 PyObject *resultobj;
6648 wxCaret *arg1 = (wxCaret *) 0 ;
6649 wxSize result;
6650 PyObject * obj0 = 0 ;
6651 char *kwnames[] = {
6652 (char *) "self", NULL
6653 };
6654
6655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6657 if (SWIG_arg_fail(1)) SWIG_fail;
6658 {
6659 PyThreadState* __tstate = wxPyBeginAllowThreads();
6660 result = (arg1)->GetSize();
6661
6662 wxPyEndAllowThreads(__tstate);
6663 if (PyErr_Occurred()) SWIG_fail;
6664 }
6665 {
6666 wxSize * resultptr;
6667 resultptr = new wxSize((wxSize &)(result));
6668 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6669 }
6670 return resultobj;
6671 fail:
6672 return NULL;
6673 }
6674
6675
6676 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6677 PyObject *resultobj;
6678 wxCaret *arg1 = (wxCaret *) 0 ;
6679 int *arg2 = (int *) 0 ;
6680 int *arg3 = (int *) 0 ;
6681 int temp2 ;
6682 int res2 = 0 ;
6683 int temp3 ;
6684 int res3 = 0 ;
6685 PyObject * obj0 = 0 ;
6686 char *kwnames[] = {
6687 (char *) "self", NULL
6688 };
6689
6690 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6691 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6694 if (SWIG_arg_fail(1)) SWIG_fail;
6695 {
6696 PyThreadState* __tstate = wxPyBeginAllowThreads();
6697 (arg1)->GetSize(arg2,arg3);
6698
6699 wxPyEndAllowThreads(__tstate);
6700 if (PyErr_Occurred()) SWIG_fail;
6701 }
6702 Py_INCREF(Py_None); resultobj = Py_None;
6703 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6704 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6705 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6706 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6714 PyObject *resultobj;
6715 wxCaret *arg1 = (wxCaret *) 0 ;
6716 wxWindow *result;
6717 PyObject * obj0 = 0 ;
6718 char *kwnames[] = {
6719 (char *) "self", NULL
6720 };
6721
6722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6724 if (SWIG_arg_fail(1)) SWIG_fail;
6725 {
6726 PyThreadState* __tstate = wxPyBeginAllowThreads();
6727 result = (wxWindow *)(arg1)->GetWindow();
6728
6729 wxPyEndAllowThreads(__tstate);
6730 if (PyErr_Occurred()) SWIG_fail;
6731 }
6732 {
6733 resultobj = wxPyMake_wxObject(result, 0);
6734 }
6735 return resultobj;
6736 fail:
6737 return NULL;
6738 }
6739
6740
6741 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6742 PyObject *resultobj;
6743 wxCaret *arg1 = (wxCaret *) 0 ;
6744 int arg2 ;
6745 int arg3 ;
6746 PyObject * obj0 = 0 ;
6747 PyObject * obj1 = 0 ;
6748 PyObject * obj2 = 0 ;
6749 char *kwnames[] = {
6750 (char *) "self",(char *) "x",(char *) "y", NULL
6751 };
6752
6753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6755 if (SWIG_arg_fail(1)) SWIG_fail;
6756 {
6757 arg2 = (int)(SWIG_As_int(obj1));
6758 if (SWIG_arg_fail(2)) SWIG_fail;
6759 }
6760 {
6761 arg3 = (int)(SWIG_As_int(obj2));
6762 if (SWIG_arg_fail(3)) SWIG_fail;
6763 }
6764 {
6765 PyThreadState* __tstate = wxPyBeginAllowThreads();
6766 (arg1)->Move(arg2,arg3);
6767
6768 wxPyEndAllowThreads(__tstate);
6769 if (PyErr_Occurred()) SWIG_fail;
6770 }
6771 Py_INCREF(Py_None); resultobj = Py_None;
6772 return resultobj;
6773 fail:
6774 return NULL;
6775 }
6776
6777
6778 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6779 PyObject *resultobj;
6780 wxCaret *arg1 = (wxCaret *) 0 ;
6781 wxPoint *arg2 = 0 ;
6782 wxPoint temp2 ;
6783 PyObject * obj0 = 0 ;
6784 PyObject * obj1 = 0 ;
6785 char *kwnames[] = {
6786 (char *) "self",(char *) "pt", NULL
6787 };
6788
6789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6791 if (SWIG_arg_fail(1)) SWIG_fail;
6792 {
6793 arg2 = &temp2;
6794 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6795 }
6796 {
6797 PyThreadState* __tstate = wxPyBeginAllowThreads();
6798 (arg1)->Move((wxPoint const &)*arg2);
6799
6800 wxPyEndAllowThreads(__tstate);
6801 if (PyErr_Occurred()) SWIG_fail;
6802 }
6803 Py_INCREF(Py_None); resultobj = Py_None;
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6811 PyObject *resultobj;
6812 wxCaret *arg1 = (wxCaret *) 0 ;
6813 int arg2 ;
6814 int arg3 ;
6815 PyObject * obj0 = 0 ;
6816 PyObject * obj1 = 0 ;
6817 PyObject * obj2 = 0 ;
6818 char *kwnames[] = {
6819 (char *) "self",(char *) "width",(char *) "height", NULL
6820 };
6821
6822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6824 if (SWIG_arg_fail(1)) SWIG_fail;
6825 {
6826 arg2 = (int)(SWIG_As_int(obj1));
6827 if (SWIG_arg_fail(2)) SWIG_fail;
6828 }
6829 {
6830 arg3 = (int)(SWIG_As_int(obj2));
6831 if (SWIG_arg_fail(3)) SWIG_fail;
6832 }
6833 {
6834 PyThreadState* __tstate = wxPyBeginAllowThreads();
6835 (arg1)->SetSize(arg2,arg3);
6836
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 Py_INCREF(Py_None); resultobj = Py_None;
6841 return resultobj;
6842 fail:
6843 return NULL;
6844 }
6845
6846
6847 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6848 PyObject *resultobj;
6849 wxCaret *arg1 = (wxCaret *) 0 ;
6850 wxSize *arg2 = 0 ;
6851 wxSize temp2 ;
6852 PyObject * obj0 = 0 ;
6853 PyObject * obj1 = 0 ;
6854 char *kwnames[] = {
6855 (char *) "self",(char *) "size", NULL
6856 };
6857
6858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6860 if (SWIG_arg_fail(1)) SWIG_fail;
6861 {
6862 arg2 = &temp2;
6863 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6864 }
6865 {
6866 PyThreadState* __tstate = wxPyBeginAllowThreads();
6867 (arg1)->SetSize((wxSize const &)*arg2);
6868
6869 wxPyEndAllowThreads(__tstate);
6870 if (PyErr_Occurred()) SWIG_fail;
6871 }
6872 Py_INCREF(Py_None); resultobj = Py_None;
6873 return resultobj;
6874 fail:
6875 return NULL;
6876 }
6877
6878
6879 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6880 PyObject *resultobj;
6881 wxCaret *arg1 = (wxCaret *) 0 ;
6882 int arg2 = (int) true ;
6883 PyObject * obj0 = 0 ;
6884 PyObject * obj1 = 0 ;
6885 char *kwnames[] = {
6886 (char *) "self",(char *) "show", NULL
6887 };
6888
6889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6891 if (SWIG_arg_fail(1)) SWIG_fail;
6892 if (obj1) {
6893 {
6894 arg2 = (int)(SWIG_As_int(obj1));
6895 if (SWIG_arg_fail(2)) SWIG_fail;
6896 }
6897 }
6898 {
6899 PyThreadState* __tstate = wxPyBeginAllowThreads();
6900 (arg1)->Show(arg2);
6901
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 Py_INCREF(Py_None); resultobj = Py_None;
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6913 PyObject *resultobj;
6914 wxCaret *arg1 = (wxCaret *) 0 ;
6915 PyObject * obj0 = 0 ;
6916 char *kwnames[] = {
6917 (char *) "self", NULL
6918 };
6919
6920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6922 if (SWIG_arg_fail(1)) SWIG_fail;
6923 {
6924 PyThreadState* __tstate = wxPyBeginAllowThreads();
6925 (arg1)->Hide();
6926
6927 wxPyEndAllowThreads(__tstate);
6928 if (PyErr_Occurred()) SWIG_fail;
6929 }
6930 Py_INCREF(Py_None); resultobj = Py_None;
6931 return resultobj;
6932 fail:
6933 return NULL;
6934 }
6935
6936
6937 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6938 PyObject *resultobj;
6939 int result;
6940 char *kwnames[] = {
6941 NULL
6942 };
6943
6944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6945 {
6946 PyThreadState* __tstate = wxPyBeginAllowThreads();
6947 result = (int)wxCaret::GetBlinkTime();
6948
6949 wxPyEndAllowThreads(__tstate);
6950 if (PyErr_Occurred()) SWIG_fail;
6951 }
6952 {
6953 resultobj = SWIG_From_int((int)(result));
6954 }
6955 return resultobj;
6956 fail:
6957 return NULL;
6958 }
6959
6960
6961 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6962 PyObject *resultobj;
6963 int arg1 ;
6964 PyObject * obj0 = 0 ;
6965 char *kwnames[] = {
6966 (char *) "milliseconds", NULL
6967 };
6968
6969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6970 {
6971 arg1 = (int)(SWIG_As_int(obj0));
6972 if (SWIG_arg_fail(1)) SWIG_fail;
6973 }
6974 {
6975 PyThreadState* __tstate = wxPyBeginAllowThreads();
6976 wxCaret::SetBlinkTime(arg1);
6977
6978 wxPyEndAllowThreads(__tstate);
6979 if (PyErr_Occurred()) SWIG_fail;
6980 }
6981 Py_INCREF(Py_None); resultobj = Py_None;
6982 return resultobj;
6983 fail:
6984 return NULL;
6985 }
6986
6987
6988 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6989 PyObject *obj;
6990 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6991 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6992 Py_INCREF(obj);
6993 return Py_BuildValue((char *)"");
6994 }
6995 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6996 PyObject *resultobj;
6997 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6998 wxBusyCursor *result;
6999 PyObject * obj0 = 0 ;
7000 char *kwnames[] = {
7001 (char *) "cursor", NULL
7002 };
7003
7004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
7005 if (obj0) {
7006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
7007 if (SWIG_arg_fail(1)) SWIG_fail;
7008 }
7009 {
7010 if (!wxPyCheckForApp()) SWIG_fail;
7011 PyThreadState* __tstate = wxPyBeginAllowThreads();
7012 result = (wxBusyCursor *)new wxBusyCursor(arg1);
7013
7014 wxPyEndAllowThreads(__tstate);
7015 if (PyErr_Occurred()) SWIG_fail;
7016 }
7017 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
7018 return resultobj;
7019 fail:
7020 return NULL;
7021 }
7022
7023
7024 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7025 PyObject *resultobj;
7026 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
7027 PyObject * obj0 = 0 ;
7028 char *kwnames[] = {
7029 (char *) "self", NULL
7030 };
7031
7032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
7033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7034 if (SWIG_arg_fail(1)) SWIG_fail;
7035 {
7036 PyThreadState* __tstate = wxPyBeginAllowThreads();
7037 delete arg1;
7038
7039 wxPyEndAllowThreads(__tstate);
7040 if (PyErr_Occurred()) SWIG_fail;
7041 }
7042 Py_INCREF(Py_None); resultobj = Py_None;
7043 return resultobj;
7044 fail:
7045 return NULL;
7046 }
7047
7048
7049 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7050 PyObject *obj;
7051 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7052 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7053 Py_INCREF(obj);
7054 return Py_BuildValue((char *)"");
7055 }
7056 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7057 PyObject *resultobj;
7058 wxWindow *arg1 = (wxWindow *) NULL ;
7059 wxWindowDisabler *result;
7060 PyObject * obj0 = 0 ;
7061 char *kwnames[] = {
7062 (char *) "winToSkip", NULL
7063 };
7064
7065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7066 if (obj0) {
7067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7068 if (SWIG_arg_fail(1)) SWIG_fail;
7069 }
7070 {
7071 if (!wxPyCheckForApp()) SWIG_fail;
7072 PyThreadState* __tstate = wxPyBeginAllowThreads();
7073 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7074
7075 wxPyEndAllowThreads(__tstate);
7076 if (PyErr_Occurred()) SWIG_fail;
7077 }
7078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7079 return resultobj;
7080 fail:
7081 return NULL;
7082 }
7083
7084
7085 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7086 PyObject *resultobj;
7087 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7088 PyObject * obj0 = 0 ;
7089 char *kwnames[] = {
7090 (char *) "self", NULL
7091 };
7092
7093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7095 if (SWIG_arg_fail(1)) SWIG_fail;
7096 {
7097 PyThreadState* __tstate = wxPyBeginAllowThreads();
7098 delete arg1;
7099
7100 wxPyEndAllowThreads(__tstate);
7101 if (PyErr_Occurred()) SWIG_fail;
7102 }
7103 Py_INCREF(Py_None); resultobj = Py_None;
7104 return resultobj;
7105 fail:
7106 return NULL;
7107 }
7108
7109
7110 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7111 PyObject *obj;
7112 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7113 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7114 Py_INCREF(obj);
7115 return Py_BuildValue((char *)"");
7116 }
7117 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7118 PyObject *resultobj;
7119 wxString *arg1 = 0 ;
7120 wxBusyInfo *result;
7121 bool temp1 = false ;
7122 PyObject * obj0 = 0 ;
7123 char *kwnames[] = {
7124 (char *) "message", NULL
7125 };
7126
7127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7128 {
7129 arg1 = wxString_in_helper(obj0);
7130 if (arg1 == NULL) SWIG_fail;
7131 temp1 = true;
7132 }
7133 {
7134 if (!wxPyCheckForApp()) SWIG_fail;
7135 PyThreadState* __tstate = wxPyBeginAllowThreads();
7136 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7137
7138 wxPyEndAllowThreads(__tstate);
7139 if (PyErr_Occurred()) SWIG_fail;
7140 }
7141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7142 {
7143 if (temp1)
7144 delete arg1;
7145 }
7146 return resultobj;
7147 fail:
7148 {
7149 if (temp1)
7150 delete arg1;
7151 }
7152 return NULL;
7153 }
7154
7155
7156 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7157 PyObject *resultobj;
7158 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7159 PyObject * obj0 = 0 ;
7160 char *kwnames[] = {
7161 (char *) "self", NULL
7162 };
7163
7164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7166 if (SWIG_arg_fail(1)) SWIG_fail;
7167 {
7168 PyThreadState* __tstate = wxPyBeginAllowThreads();
7169 delete arg1;
7170
7171 wxPyEndAllowThreads(__tstate);
7172 if (PyErr_Occurred()) SWIG_fail;
7173 }
7174 Py_INCREF(Py_None); resultobj = Py_None;
7175 return resultobj;
7176 fail:
7177 return NULL;
7178 }
7179
7180
7181 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7182 PyObject *obj;
7183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7184 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7185 Py_INCREF(obj);
7186 return Py_BuildValue((char *)"");
7187 }
7188 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7189 PyObject *resultobj;
7190 wxStopWatch *result;
7191 char *kwnames[] = {
7192 NULL
7193 };
7194
7195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7196 {
7197 PyThreadState* __tstate = wxPyBeginAllowThreads();
7198 result = (wxStopWatch *)new wxStopWatch();
7199
7200 wxPyEndAllowThreads(__tstate);
7201 if (PyErr_Occurred()) SWIG_fail;
7202 }
7203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7204 return resultobj;
7205 fail:
7206 return NULL;
7207 }
7208
7209
7210 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7211 PyObject *resultobj;
7212 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7213 long arg2 = (long) 0 ;
7214 PyObject * obj0 = 0 ;
7215 PyObject * obj1 = 0 ;
7216 char *kwnames[] = {
7217 (char *) "self",(char *) "t0", NULL
7218 };
7219
7220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7222 if (SWIG_arg_fail(1)) SWIG_fail;
7223 if (obj1) {
7224 {
7225 arg2 = (long)(SWIG_As_long(obj1));
7226 if (SWIG_arg_fail(2)) SWIG_fail;
7227 }
7228 }
7229 {
7230 PyThreadState* __tstate = wxPyBeginAllowThreads();
7231 (arg1)->Start(arg2);
7232
7233 wxPyEndAllowThreads(__tstate);
7234 if (PyErr_Occurred()) SWIG_fail;
7235 }
7236 Py_INCREF(Py_None); resultobj = Py_None;
7237 return resultobj;
7238 fail:
7239 return NULL;
7240 }
7241
7242
7243 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7244 PyObject *resultobj;
7245 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7246 PyObject * obj0 = 0 ;
7247 char *kwnames[] = {
7248 (char *) "self", NULL
7249 };
7250
7251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7253 if (SWIG_arg_fail(1)) SWIG_fail;
7254 {
7255 PyThreadState* __tstate = wxPyBeginAllowThreads();
7256 (arg1)->Pause();
7257
7258 wxPyEndAllowThreads(__tstate);
7259 if (PyErr_Occurred()) SWIG_fail;
7260 }
7261 Py_INCREF(Py_None); resultobj = Py_None;
7262 return resultobj;
7263 fail:
7264 return NULL;
7265 }
7266
7267
7268 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7269 PyObject *resultobj;
7270 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7271 PyObject * obj0 = 0 ;
7272 char *kwnames[] = {
7273 (char *) "self", NULL
7274 };
7275
7276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7278 if (SWIG_arg_fail(1)) SWIG_fail;
7279 {
7280 PyThreadState* __tstate = wxPyBeginAllowThreads();
7281 (arg1)->Resume();
7282
7283 wxPyEndAllowThreads(__tstate);
7284 if (PyErr_Occurred()) SWIG_fail;
7285 }
7286 Py_INCREF(Py_None); resultobj = Py_None;
7287 return resultobj;
7288 fail:
7289 return NULL;
7290 }
7291
7292
7293 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7294 PyObject *resultobj;
7295 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7296 long result;
7297 PyObject * obj0 = 0 ;
7298 char *kwnames[] = {
7299 (char *) "self", NULL
7300 };
7301
7302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7304 if (SWIG_arg_fail(1)) SWIG_fail;
7305 {
7306 PyThreadState* __tstate = wxPyBeginAllowThreads();
7307 result = (long)((wxStopWatch const *)arg1)->Time();
7308
7309 wxPyEndAllowThreads(__tstate);
7310 if (PyErr_Occurred()) SWIG_fail;
7311 }
7312 {
7313 resultobj = SWIG_From_long((long)(result));
7314 }
7315 return resultobj;
7316 fail:
7317 return NULL;
7318 }
7319
7320
7321 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7322 PyObject *obj;
7323 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7324 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7325 Py_INCREF(obj);
7326 return Py_BuildValue((char *)"");
7327 }
7328 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7329 PyObject *resultobj;
7330 int arg1 = (int) 9 ;
7331 int arg2 = (int) wxID_FILE1 ;
7332 wxFileHistory *result;
7333 PyObject * obj0 = 0 ;
7334 PyObject * obj1 = 0 ;
7335 char *kwnames[] = {
7336 (char *) "maxFiles",(char *) "idBase", NULL
7337 };
7338
7339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7340 if (obj0) {
7341 {
7342 arg1 = (int)(SWIG_As_int(obj0));
7343 if (SWIG_arg_fail(1)) SWIG_fail;
7344 }
7345 }
7346 if (obj1) {
7347 {
7348 arg2 = (int)(SWIG_As_int(obj1));
7349 if (SWIG_arg_fail(2)) SWIG_fail;
7350 }
7351 }
7352 {
7353 PyThreadState* __tstate = wxPyBeginAllowThreads();
7354 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7355
7356 wxPyEndAllowThreads(__tstate);
7357 if (PyErr_Occurred()) SWIG_fail;
7358 }
7359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7360 return resultobj;
7361 fail:
7362 return NULL;
7363 }
7364
7365
7366 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7367 PyObject *resultobj;
7368 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7369 PyObject * obj0 = 0 ;
7370 char *kwnames[] = {
7371 (char *) "self", NULL
7372 };
7373
7374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7376 if (SWIG_arg_fail(1)) SWIG_fail;
7377 {
7378 PyThreadState* __tstate = wxPyBeginAllowThreads();
7379 delete arg1;
7380
7381 wxPyEndAllowThreads(__tstate);
7382 if (PyErr_Occurred()) SWIG_fail;
7383 }
7384 Py_INCREF(Py_None); resultobj = Py_None;
7385 return resultobj;
7386 fail:
7387 return NULL;
7388 }
7389
7390
7391 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7392 PyObject *resultobj;
7393 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7394 wxString *arg2 = 0 ;
7395 bool temp2 = false ;
7396 PyObject * obj0 = 0 ;
7397 PyObject * obj1 = 0 ;
7398 char *kwnames[] = {
7399 (char *) "self",(char *) "file", NULL
7400 };
7401
7402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7404 if (SWIG_arg_fail(1)) SWIG_fail;
7405 {
7406 arg2 = wxString_in_helper(obj1);
7407 if (arg2 == NULL) SWIG_fail;
7408 temp2 = true;
7409 }
7410 {
7411 PyThreadState* __tstate = wxPyBeginAllowThreads();
7412 (arg1)->AddFileToHistory((wxString const &)*arg2);
7413
7414 wxPyEndAllowThreads(__tstate);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 Py_INCREF(Py_None); resultobj = Py_None;
7418 {
7419 if (temp2)
7420 delete arg2;
7421 }
7422 return resultobj;
7423 fail:
7424 {
7425 if (temp2)
7426 delete arg2;
7427 }
7428 return NULL;
7429 }
7430
7431
7432 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7433 PyObject *resultobj;
7434 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7435 int arg2 ;
7436 PyObject * obj0 = 0 ;
7437 PyObject * obj1 = 0 ;
7438 char *kwnames[] = {
7439 (char *) "self",(char *) "i", NULL
7440 };
7441
7442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7444 if (SWIG_arg_fail(1)) SWIG_fail;
7445 {
7446 arg2 = (int)(SWIG_As_int(obj1));
7447 if (SWIG_arg_fail(2)) SWIG_fail;
7448 }
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 (arg1)->RemoveFileFromHistory(arg2);
7452
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 Py_INCREF(Py_None); resultobj = Py_None;
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7464 PyObject *resultobj;
7465 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7466 int result;
7467 PyObject * obj0 = 0 ;
7468 char *kwnames[] = {
7469 (char *) "self", NULL
7470 };
7471
7472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7474 if (SWIG_arg_fail(1)) SWIG_fail;
7475 {
7476 PyThreadState* __tstate = wxPyBeginAllowThreads();
7477 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7478
7479 wxPyEndAllowThreads(__tstate);
7480 if (PyErr_Occurred()) SWIG_fail;
7481 }
7482 {
7483 resultobj = SWIG_From_int((int)(result));
7484 }
7485 return resultobj;
7486 fail:
7487 return NULL;
7488 }
7489
7490
7491 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7492 PyObject *resultobj;
7493 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7494 wxMenu *arg2 = (wxMenu *) 0 ;
7495 PyObject * obj0 = 0 ;
7496 PyObject * obj1 = 0 ;
7497 char *kwnames[] = {
7498 (char *) "self",(char *) "menu", NULL
7499 };
7500
7501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7503 if (SWIG_arg_fail(1)) SWIG_fail;
7504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7505 if (SWIG_arg_fail(2)) SWIG_fail;
7506 {
7507 PyThreadState* __tstate = wxPyBeginAllowThreads();
7508 (arg1)->UseMenu(arg2);
7509
7510 wxPyEndAllowThreads(__tstate);
7511 if (PyErr_Occurred()) SWIG_fail;
7512 }
7513 Py_INCREF(Py_None); resultobj = Py_None;
7514 return resultobj;
7515 fail:
7516 return NULL;
7517 }
7518
7519
7520 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7521 PyObject *resultobj;
7522 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7523 wxMenu *arg2 = (wxMenu *) 0 ;
7524 PyObject * obj0 = 0 ;
7525 PyObject * obj1 = 0 ;
7526 char *kwnames[] = {
7527 (char *) "self",(char *) "menu", NULL
7528 };
7529
7530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7532 if (SWIG_arg_fail(1)) SWIG_fail;
7533 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7534 if (SWIG_arg_fail(2)) SWIG_fail;
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 (arg1)->RemoveMenu(arg2);
7538
7539 wxPyEndAllowThreads(__tstate);
7540 if (PyErr_Occurred()) SWIG_fail;
7541 }
7542 Py_INCREF(Py_None); resultobj = Py_None;
7543 return resultobj;
7544 fail:
7545 return NULL;
7546 }
7547
7548
7549 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7550 PyObject *resultobj;
7551 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7552 wxConfigBase *arg2 = 0 ;
7553 PyObject * obj0 = 0 ;
7554 PyObject * obj1 = 0 ;
7555 char *kwnames[] = {
7556 (char *) "self",(char *) "config", NULL
7557 };
7558
7559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7561 if (SWIG_arg_fail(1)) SWIG_fail;
7562 {
7563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7564 if (SWIG_arg_fail(2)) SWIG_fail;
7565 if (arg2 == NULL) {
7566 SWIG_null_ref("wxConfigBase");
7567 }
7568 if (SWIG_arg_fail(2)) SWIG_fail;
7569 }
7570 {
7571 PyThreadState* __tstate = wxPyBeginAllowThreads();
7572 (arg1)->Load(*arg2);
7573
7574 wxPyEndAllowThreads(__tstate);
7575 if (PyErr_Occurred()) SWIG_fail;
7576 }
7577 Py_INCREF(Py_None); resultobj = Py_None;
7578 return resultobj;
7579 fail:
7580 return NULL;
7581 }
7582
7583
7584 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7585 PyObject *resultobj;
7586 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7587 wxConfigBase *arg2 = 0 ;
7588 PyObject * obj0 = 0 ;
7589 PyObject * obj1 = 0 ;
7590 char *kwnames[] = {
7591 (char *) "self",(char *) "config", NULL
7592 };
7593
7594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7596 if (SWIG_arg_fail(1)) SWIG_fail;
7597 {
7598 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7599 if (SWIG_arg_fail(2)) SWIG_fail;
7600 if (arg2 == NULL) {
7601 SWIG_null_ref("wxConfigBase");
7602 }
7603 if (SWIG_arg_fail(2)) SWIG_fail;
7604 }
7605 {
7606 PyThreadState* __tstate = wxPyBeginAllowThreads();
7607 (arg1)->Save(*arg2);
7608
7609 wxPyEndAllowThreads(__tstate);
7610 if (PyErr_Occurred()) SWIG_fail;
7611 }
7612 Py_INCREF(Py_None); resultobj = Py_None;
7613 return resultobj;
7614 fail:
7615 return NULL;
7616 }
7617
7618
7619 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7620 PyObject *resultobj;
7621 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7622 PyObject * obj0 = 0 ;
7623 char *kwnames[] = {
7624 (char *) "self", NULL
7625 };
7626
7627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7629 if (SWIG_arg_fail(1)) SWIG_fail;
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 (arg1)->AddFilesToMenu();
7633
7634 wxPyEndAllowThreads(__tstate);
7635 if (PyErr_Occurred()) SWIG_fail;
7636 }
7637 Py_INCREF(Py_None); resultobj = Py_None;
7638 return resultobj;
7639 fail:
7640 return NULL;
7641 }
7642
7643
7644 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7645 PyObject *resultobj;
7646 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7647 wxMenu *arg2 = (wxMenu *) 0 ;
7648 PyObject * obj0 = 0 ;
7649 PyObject * obj1 = 0 ;
7650 char *kwnames[] = {
7651 (char *) "self",(char *) "menu", NULL
7652 };
7653
7654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7656 if (SWIG_arg_fail(1)) SWIG_fail;
7657 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7658 if (SWIG_arg_fail(2)) SWIG_fail;
7659 {
7660 PyThreadState* __tstate = wxPyBeginAllowThreads();
7661 (arg1)->AddFilesToMenu(arg2);
7662
7663 wxPyEndAllowThreads(__tstate);
7664 if (PyErr_Occurred()) SWIG_fail;
7665 }
7666 Py_INCREF(Py_None); resultobj = Py_None;
7667 return resultobj;
7668 fail:
7669 return NULL;
7670 }
7671
7672
7673 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7674 PyObject *resultobj;
7675 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7676 int arg2 ;
7677 wxString result;
7678 PyObject * obj0 = 0 ;
7679 PyObject * obj1 = 0 ;
7680 char *kwnames[] = {
7681 (char *) "self",(char *) "i", NULL
7682 };
7683
7684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7686 if (SWIG_arg_fail(1)) SWIG_fail;
7687 {
7688 arg2 = (int)(SWIG_As_int(obj1));
7689 if (SWIG_arg_fail(2)) SWIG_fail;
7690 }
7691 {
7692 PyThreadState* __tstate = wxPyBeginAllowThreads();
7693 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7694
7695 wxPyEndAllowThreads(__tstate);
7696 if (PyErr_Occurred()) SWIG_fail;
7697 }
7698 {
7699 #if wxUSE_UNICODE
7700 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7701 #else
7702 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7703 #endif
7704 }
7705 return resultobj;
7706 fail:
7707 return NULL;
7708 }
7709
7710
7711 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7712 PyObject *resultobj;
7713 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7714 int result;
7715 PyObject * obj0 = 0 ;
7716 char *kwnames[] = {
7717 (char *) "self", NULL
7718 };
7719
7720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7722 if (SWIG_arg_fail(1)) SWIG_fail;
7723 {
7724 PyThreadState* __tstate = wxPyBeginAllowThreads();
7725 result = (int)((wxFileHistory const *)arg1)->GetCount();
7726
7727 wxPyEndAllowThreads(__tstate);
7728 if (PyErr_Occurred()) SWIG_fail;
7729 }
7730 {
7731 resultobj = SWIG_From_int((int)(result));
7732 }
7733 return resultobj;
7734 fail:
7735 return NULL;
7736 }
7737
7738
7739 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7740 PyObject *obj;
7741 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7742 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7743 Py_INCREF(obj);
7744 return Py_BuildValue((char *)"");
7745 }
7746 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7747 PyObject *resultobj;
7748 wxString *arg1 = 0 ;
7749 wxString const &arg2_defvalue = wxPyEmptyString ;
7750 wxString *arg2 = (wxString *) &arg2_defvalue ;
7751 wxSingleInstanceChecker *result;
7752 bool temp1 = false ;
7753 bool temp2 = false ;
7754 PyObject * obj0 = 0 ;
7755 PyObject * obj1 = 0 ;
7756 char *kwnames[] = {
7757 (char *) "name",(char *) "path", NULL
7758 };
7759
7760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7761 {
7762 arg1 = wxString_in_helper(obj0);
7763 if (arg1 == NULL) SWIG_fail;
7764 temp1 = true;
7765 }
7766 if (obj1) {
7767 {
7768 arg2 = wxString_in_helper(obj1);
7769 if (arg2 == NULL) SWIG_fail;
7770 temp2 = true;
7771 }
7772 }
7773 {
7774 PyThreadState* __tstate = wxPyBeginAllowThreads();
7775 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7776
7777 wxPyEndAllowThreads(__tstate);
7778 if (PyErr_Occurred()) SWIG_fail;
7779 }
7780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7781 {
7782 if (temp1)
7783 delete arg1;
7784 }
7785 {
7786 if (temp2)
7787 delete arg2;
7788 }
7789 return resultobj;
7790 fail:
7791 {
7792 if (temp1)
7793 delete arg1;
7794 }
7795 {
7796 if (temp2)
7797 delete arg2;
7798 }
7799 return NULL;
7800 }
7801
7802
7803 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7804 PyObject *resultobj;
7805 wxSingleInstanceChecker *result;
7806 char *kwnames[] = {
7807 NULL
7808 };
7809
7810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7811 {
7812 PyThreadState* __tstate = wxPyBeginAllowThreads();
7813 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7814
7815 wxPyEndAllowThreads(__tstate);
7816 if (PyErr_Occurred()) SWIG_fail;
7817 }
7818 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7819 return resultobj;
7820 fail:
7821 return NULL;
7822 }
7823
7824
7825 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7826 PyObject *resultobj;
7827 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7828 PyObject * obj0 = 0 ;
7829 char *kwnames[] = {
7830 (char *) "self", NULL
7831 };
7832
7833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7835 if (SWIG_arg_fail(1)) SWIG_fail;
7836 {
7837 PyThreadState* __tstate = wxPyBeginAllowThreads();
7838 delete arg1;
7839
7840 wxPyEndAllowThreads(__tstate);
7841 if (PyErr_Occurred()) SWIG_fail;
7842 }
7843 Py_INCREF(Py_None); resultobj = Py_None;
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj;
7852 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7853 wxString *arg2 = 0 ;
7854 wxString const &arg3_defvalue = wxPyEmptyString ;
7855 wxString *arg3 = (wxString *) &arg3_defvalue ;
7856 bool result;
7857 bool temp2 = false ;
7858 bool temp3 = false ;
7859 PyObject * obj0 = 0 ;
7860 PyObject * obj1 = 0 ;
7861 PyObject * obj2 = 0 ;
7862 char *kwnames[] = {
7863 (char *) "self",(char *) "name",(char *) "path", NULL
7864 };
7865
7866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7868 if (SWIG_arg_fail(1)) SWIG_fail;
7869 {
7870 arg2 = wxString_in_helper(obj1);
7871 if (arg2 == NULL) SWIG_fail;
7872 temp2 = true;
7873 }
7874 if (obj2) {
7875 {
7876 arg3 = wxString_in_helper(obj2);
7877 if (arg3 == NULL) SWIG_fail;
7878 temp3 = true;
7879 }
7880 }
7881 {
7882 PyThreadState* __tstate = wxPyBeginAllowThreads();
7883 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7884
7885 wxPyEndAllowThreads(__tstate);
7886 if (PyErr_Occurred()) SWIG_fail;
7887 }
7888 {
7889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7890 }
7891 {
7892 if (temp2)
7893 delete arg2;
7894 }
7895 {
7896 if (temp3)
7897 delete arg3;
7898 }
7899 return resultobj;
7900 fail:
7901 {
7902 if (temp2)
7903 delete arg2;
7904 }
7905 {
7906 if (temp3)
7907 delete arg3;
7908 }
7909 return NULL;
7910 }
7911
7912
7913 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7914 PyObject *resultobj;
7915 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7916 bool result;
7917 PyObject * obj0 = 0 ;
7918 char *kwnames[] = {
7919 (char *) "self", NULL
7920 };
7921
7922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7924 if (SWIG_arg_fail(1)) SWIG_fail;
7925 {
7926 PyThreadState* __tstate = wxPyBeginAllowThreads();
7927 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7928
7929 wxPyEndAllowThreads(__tstate);
7930 if (PyErr_Occurred()) SWIG_fail;
7931 }
7932 {
7933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7934 }
7935 return resultobj;
7936 fail:
7937 return NULL;
7938 }
7939
7940
7941 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7942 PyObject *obj;
7943 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7944 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7945 Py_INCREF(obj);
7946 return Py_BuildValue((char *)"");
7947 }
7948 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7949 PyObject *resultobj;
7950 wxWindow *arg1 = (wxWindow *) 0 ;
7951 wxDC *arg2 = 0 ;
7952 bool result;
7953 PyObject * obj0 = 0 ;
7954 PyObject * obj1 = 0 ;
7955 char *kwnames[] = {
7956 (char *) "window",(char *) "dc", NULL
7957 };
7958
7959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7961 if (SWIG_arg_fail(1)) SWIG_fail;
7962 {
7963 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7964 if (SWIG_arg_fail(2)) SWIG_fail;
7965 if (arg2 == NULL) {
7966 SWIG_null_ref("wxDC");
7967 }
7968 if (SWIG_arg_fail(2)) SWIG_fail;
7969 }
7970 {
7971 PyThreadState* __tstate = wxPyBeginAllowThreads();
7972 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7973
7974 wxPyEndAllowThreads(__tstate);
7975 if (PyErr_Occurred()) SWIG_fail;
7976 }
7977 {
7978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7979 }
7980 return resultobj;
7981 fail:
7982 return NULL;
7983 }
7984
7985
7986 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7987 PyObject *resultobj;
7988 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7989 PyObject * obj0 = 0 ;
7990 char *kwnames[] = {
7991 (char *) "self", NULL
7992 };
7993
7994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7996 if (SWIG_arg_fail(1)) SWIG_fail;
7997 {
7998 PyThreadState* __tstate = wxPyBeginAllowThreads();
7999 delete arg1;
8000
8001 wxPyEndAllowThreads(__tstate);
8002 if (PyErr_Occurred()) SWIG_fail;
8003 }
8004 Py_INCREF(Py_None); resultobj = Py_None;
8005 return resultobj;
8006 fail:
8007 return NULL;
8008 }
8009
8010
8011 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
8012 PyObject *resultobj;
8013 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8014 wxString result;
8015 PyObject * obj0 = 0 ;
8016 char *kwnames[] = {
8017 (char *) "self", NULL
8018 };
8019
8020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
8021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8022 if (SWIG_arg_fail(1)) SWIG_fail;
8023 {
8024 PyThreadState* __tstate = wxPyBeginAllowThreads();
8025 result = (arg1)->GetTip();
8026
8027 wxPyEndAllowThreads(__tstate);
8028 if (PyErr_Occurred()) SWIG_fail;
8029 }
8030 {
8031 #if wxUSE_UNICODE
8032 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8033 #else
8034 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8035 #endif
8036 }
8037 return resultobj;
8038 fail:
8039 return NULL;
8040 }
8041
8042
8043 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8044 PyObject *resultobj;
8045 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8046 size_t result;
8047 PyObject * obj0 = 0 ;
8048 char *kwnames[] = {
8049 (char *) "self", NULL
8050 };
8051
8052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8054 if (SWIG_arg_fail(1)) SWIG_fail;
8055 {
8056 PyThreadState* __tstate = wxPyBeginAllowThreads();
8057 result = (size_t)(arg1)->GetCurrentTip();
8058
8059 wxPyEndAllowThreads(__tstate);
8060 if (PyErr_Occurred()) SWIG_fail;
8061 }
8062 {
8063 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8064 }
8065 return resultobj;
8066 fail:
8067 return NULL;
8068 }
8069
8070
8071 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8072 PyObject *resultobj;
8073 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8074 wxString *arg2 = 0 ;
8075 wxString result;
8076 bool temp2 = false ;
8077 PyObject * obj0 = 0 ;
8078 PyObject * obj1 = 0 ;
8079 char *kwnames[] = {
8080 (char *) "self",(char *) "tip", NULL
8081 };
8082
8083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8085 if (SWIG_arg_fail(1)) SWIG_fail;
8086 {
8087 arg2 = wxString_in_helper(obj1);
8088 if (arg2 == NULL) SWIG_fail;
8089 temp2 = true;
8090 }
8091 {
8092 PyThreadState* __tstate = wxPyBeginAllowThreads();
8093 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8094
8095 wxPyEndAllowThreads(__tstate);
8096 if (PyErr_Occurred()) SWIG_fail;
8097 }
8098 {
8099 #if wxUSE_UNICODE
8100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8101 #else
8102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8103 #endif
8104 }
8105 {
8106 if (temp2)
8107 delete arg2;
8108 }
8109 return resultobj;
8110 fail:
8111 {
8112 if (temp2)
8113 delete arg2;
8114 }
8115 return NULL;
8116 }
8117
8118
8119 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8120 PyObject *obj;
8121 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8122 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8123 Py_INCREF(obj);
8124 return Py_BuildValue((char *)"");
8125 }
8126 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8127 PyObject *resultobj;
8128 size_t arg1 ;
8129 wxPyTipProvider *result;
8130 PyObject * obj0 = 0 ;
8131 char *kwnames[] = {
8132 (char *) "currentTip", NULL
8133 };
8134
8135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8136 {
8137 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8138 if (SWIG_arg_fail(1)) SWIG_fail;
8139 }
8140 {
8141 PyThreadState* __tstate = wxPyBeginAllowThreads();
8142 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8143
8144 wxPyEndAllowThreads(__tstate);
8145 if (PyErr_Occurred()) SWIG_fail;
8146 }
8147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8148 return resultobj;
8149 fail:
8150 return NULL;
8151 }
8152
8153
8154 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8155 PyObject *resultobj;
8156 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8157 PyObject *arg2 = (PyObject *) 0 ;
8158 PyObject *arg3 = (PyObject *) 0 ;
8159 PyObject * obj0 = 0 ;
8160 PyObject * obj1 = 0 ;
8161 PyObject * obj2 = 0 ;
8162 char *kwnames[] = {
8163 (char *) "self",(char *) "self",(char *) "_class", NULL
8164 };
8165
8166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8168 if (SWIG_arg_fail(1)) SWIG_fail;
8169 arg2 = obj1;
8170 arg3 = obj2;
8171 {
8172 PyThreadState* __tstate = wxPyBeginAllowThreads();
8173 (arg1)->_setCallbackInfo(arg2,arg3);
8174
8175 wxPyEndAllowThreads(__tstate);
8176 if (PyErr_Occurred()) SWIG_fail;
8177 }
8178 Py_INCREF(Py_None); resultobj = Py_None;
8179 return resultobj;
8180 fail:
8181 return NULL;
8182 }
8183
8184
8185 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8186 PyObject *obj;
8187 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8188 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8189 Py_INCREF(obj);
8190 return Py_BuildValue((char *)"");
8191 }
8192 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8193 PyObject *resultobj;
8194 wxWindow *arg1 = (wxWindow *) 0 ;
8195 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8196 bool arg3 = (bool) true ;
8197 bool result;
8198 PyObject * obj0 = 0 ;
8199 PyObject * obj1 = 0 ;
8200 PyObject * obj2 = 0 ;
8201 char *kwnames[] = {
8202 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8203 };
8204
8205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8207 if (SWIG_arg_fail(1)) SWIG_fail;
8208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8209 if (SWIG_arg_fail(2)) SWIG_fail;
8210 if (obj2) {
8211 {
8212 arg3 = (bool)(SWIG_As_bool(obj2));
8213 if (SWIG_arg_fail(3)) SWIG_fail;
8214 }
8215 }
8216 {
8217 if (!wxPyCheckForApp()) SWIG_fail;
8218 PyThreadState* __tstate = wxPyBeginAllowThreads();
8219 result = (bool)wxShowTip(arg1,arg2,arg3);
8220
8221 wxPyEndAllowThreads(__tstate);
8222 if (PyErr_Occurred()) SWIG_fail;
8223 }
8224 {
8225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8226 }
8227 return resultobj;
8228 fail:
8229 return NULL;
8230 }
8231
8232
8233 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8234 PyObject *resultobj;
8235 wxString *arg1 = 0 ;
8236 size_t arg2 ;
8237 wxTipProvider *result;
8238 bool temp1 = false ;
8239 PyObject * obj0 = 0 ;
8240 PyObject * obj1 = 0 ;
8241 char *kwnames[] = {
8242 (char *) "filename",(char *) "currentTip", NULL
8243 };
8244
8245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8246 {
8247 arg1 = wxString_in_helper(obj0);
8248 if (arg1 == NULL) SWIG_fail;
8249 temp1 = true;
8250 }
8251 {
8252 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8253 if (SWIG_arg_fail(2)) SWIG_fail;
8254 }
8255 {
8256 if (!wxPyCheckForApp()) SWIG_fail;
8257 PyThreadState* __tstate = wxPyBeginAllowThreads();
8258 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8259
8260 wxPyEndAllowThreads(__tstate);
8261 if (PyErr_Occurred()) SWIG_fail;
8262 }
8263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8264 {
8265 if (temp1)
8266 delete arg1;
8267 }
8268 return resultobj;
8269 fail:
8270 {
8271 if (temp1)
8272 delete arg1;
8273 }
8274 return NULL;
8275 }
8276
8277
8278 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8279 PyObject *resultobj;
8280 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8281 int arg2 = (int) -1 ;
8282 wxPyTimer *result;
8283 PyObject * obj0 = 0 ;
8284 PyObject * obj1 = 0 ;
8285 char *kwnames[] = {
8286 (char *) "owner",(char *) "id", NULL
8287 };
8288
8289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8290 if (obj0) {
8291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8292 if (SWIG_arg_fail(1)) SWIG_fail;
8293 }
8294 if (obj1) {
8295 {
8296 arg2 = (int)(SWIG_As_int(obj1));
8297 if (SWIG_arg_fail(2)) SWIG_fail;
8298 }
8299 }
8300 {
8301 if (!wxPyCheckForApp()) SWIG_fail;
8302 PyThreadState* __tstate = wxPyBeginAllowThreads();
8303 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8304
8305 wxPyEndAllowThreads(__tstate);
8306 if (PyErr_Occurred()) SWIG_fail;
8307 }
8308 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8309 return resultobj;
8310 fail:
8311 return NULL;
8312 }
8313
8314
8315 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8316 PyObject *resultobj;
8317 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8318 PyObject * obj0 = 0 ;
8319 char *kwnames[] = {
8320 (char *) "self", NULL
8321 };
8322
8323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8325 if (SWIG_arg_fail(1)) SWIG_fail;
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 delete arg1;
8329
8330 wxPyEndAllowThreads(__tstate);
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 Py_INCREF(Py_None); resultobj = Py_None;
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj;
8342 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8343 PyObject *arg2 = (PyObject *) 0 ;
8344 PyObject *arg3 = (PyObject *) 0 ;
8345 int arg4 = (int) 1 ;
8346 PyObject * obj0 = 0 ;
8347 PyObject * obj1 = 0 ;
8348 PyObject * obj2 = 0 ;
8349 PyObject * obj3 = 0 ;
8350 char *kwnames[] = {
8351 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8352 };
8353
8354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8356 if (SWIG_arg_fail(1)) SWIG_fail;
8357 arg2 = obj1;
8358 arg3 = obj2;
8359 if (obj3) {
8360 {
8361 arg4 = (int)(SWIG_As_int(obj3));
8362 if (SWIG_arg_fail(4)) SWIG_fail;
8363 }
8364 }
8365 {
8366 PyThreadState* __tstate = wxPyBeginAllowThreads();
8367 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8368
8369 wxPyEndAllowThreads(__tstate);
8370 if (PyErr_Occurred()) SWIG_fail;
8371 }
8372 Py_INCREF(Py_None); resultobj = Py_None;
8373 return resultobj;
8374 fail:
8375 return NULL;
8376 }
8377
8378
8379 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8380 PyObject *resultobj;
8381 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8382 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8383 int arg3 = (int) -1 ;
8384 PyObject * obj0 = 0 ;
8385 PyObject * obj1 = 0 ;
8386 PyObject * obj2 = 0 ;
8387 char *kwnames[] = {
8388 (char *) "self",(char *) "owner",(char *) "id", NULL
8389 };
8390
8391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8393 if (SWIG_arg_fail(1)) SWIG_fail;
8394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8395 if (SWIG_arg_fail(2)) SWIG_fail;
8396 if (obj2) {
8397 {
8398 arg3 = (int)(SWIG_As_int(obj2));
8399 if (SWIG_arg_fail(3)) SWIG_fail;
8400 }
8401 }
8402 {
8403 PyThreadState* __tstate = wxPyBeginAllowThreads();
8404 (arg1)->SetOwner(arg2,arg3);
8405
8406 wxPyEndAllowThreads(__tstate);
8407 if (PyErr_Occurred()) SWIG_fail;
8408 }
8409 Py_INCREF(Py_None); resultobj = Py_None;
8410 return resultobj;
8411 fail:
8412 return NULL;
8413 }
8414
8415
8416 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8417 PyObject *resultobj;
8418 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8419 wxEvtHandler *result;
8420 PyObject * obj0 = 0 ;
8421 char *kwnames[] = {
8422 (char *) "self", NULL
8423 };
8424
8425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8427 if (SWIG_arg_fail(1)) SWIG_fail;
8428 {
8429 PyThreadState* __tstate = wxPyBeginAllowThreads();
8430 result = (wxEvtHandler *)(arg1)->GetOwner();
8431
8432 wxPyEndAllowThreads(__tstate);
8433 if (PyErr_Occurred()) SWIG_fail;
8434 }
8435 {
8436 resultobj = wxPyMake_wxObject(result, 0);
8437 }
8438 return resultobj;
8439 fail:
8440 return NULL;
8441 }
8442
8443
8444 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8445 PyObject *resultobj;
8446 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8447 int arg2 = (int) -1 ;
8448 bool arg3 = (bool) false ;
8449 bool result;
8450 PyObject * obj0 = 0 ;
8451 PyObject * obj1 = 0 ;
8452 PyObject * obj2 = 0 ;
8453 char *kwnames[] = {
8454 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8455 };
8456
8457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8459 if (SWIG_arg_fail(1)) SWIG_fail;
8460 if (obj1) {
8461 {
8462 arg2 = (int)(SWIG_As_int(obj1));
8463 if (SWIG_arg_fail(2)) SWIG_fail;
8464 }
8465 }
8466 if (obj2) {
8467 {
8468 arg3 = (bool)(SWIG_As_bool(obj2));
8469 if (SWIG_arg_fail(3)) SWIG_fail;
8470 }
8471 }
8472 {
8473 PyThreadState* __tstate = wxPyBeginAllowThreads();
8474 result = (bool)(arg1)->Start(arg2,arg3);
8475
8476 wxPyEndAllowThreads(__tstate);
8477 if (PyErr_Occurred()) SWIG_fail;
8478 }
8479 {
8480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8481 }
8482 return resultobj;
8483 fail:
8484 return NULL;
8485 }
8486
8487
8488 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8489 PyObject *resultobj;
8490 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8491 PyObject * obj0 = 0 ;
8492 char *kwnames[] = {
8493 (char *) "self", NULL
8494 };
8495
8496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8498 if (SWIG_arg_fail(1)) SWIG_fail;
8499 {
8500 PyThreadState* __tstate = wxPyBeginAllowThreads();
8501 (arg1)->Stop();
8502
8503 wxPyEndAllowThreads(__tstate);
8504 if (PyErr_Occurred()) SWIG_fail;
8505 }
8506 Py_INCREF(Py_None); resultobj = Py_None;
8507 return resultobj;
8508 fail:
8509 return NULL;
8510 }
8511
8512
8513 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8514 PyObject *resultobj;
8515 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8516 bool result;
8517 PyObject * obj0 = 0 ;
8518 char *kwnames[] = {
8519 (char *) "self", NULL
8520 };
8521
8522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8524 if (SWIG_arg_fail(1)) SWIG_fail;
8525 {
8526 PyThreadState* __tstate = wxPyBeginAllowThreads();
8527 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8528
8529 wxPyEndAllowThreads(__tstate);
8530 if (PyErr_Occurred()) SWIG_fail;
8531 }
8532 {
8533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8534 }
8535 return resultobj;
8536 fail:
8537 return NULL;
8538 }
8539
8540
8541 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8542 PyObject *resultobj;
8543 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8544 int result;
8545 PyObject * obj0 = 0 ;
8546 char *kwnames[] = {
8547 (char *) "self", NULL
8548 };
8549
8550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8552 if (SWIG_arg_fail(1)) SWIG_fail;
8553 {
8554 PyThreadState* __tstate = wxPyBeginAllowThreads();
8555 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8556
8557 wxPyEndAllowThreads(__tstate);
8558 if (PyErr_Occurred()) SWIG_fail;
8559 }
8560 {
8561 resultobj = SWIG_From_int((int)(result));
8562 }
8563 return resultobj;
8564 fail:
8565 return NULL;
8566 }
8567
8568
8569 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8570 PyObject *resultobj;
8571 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8572 bool result;
8573 PyObject * obj0 = 0 ;
8574 char *kwnames[] = {
8575 (char *) "self", NULL
8576 };
8577
8578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8580 if (SWIG_arg_fail(1)) SWIG_fail;
8581 {
8582 PyThreadState* __tstate = wxPyBeginAllowThreads();
8583 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8584
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 {
8589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8590 }
8591 return resultobj;
8592 fail:
8593 return NULL;
8594 }
8595
8596
8597 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8598 PyObject *resultobj;
8599 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8600 int result;
8601 PyObject * obj0 = 0 ;
8602 char *kwnames[] = {
8603 (char *) "self", NULL
8604 };
8605
8606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8608 if (SWIG_arg_fail(1)) SWIG_fail;
8609 {
8610 PyThreadState* __tstate = wxPyBeginAllowThreads();
8611 result = (int)((wxPyTimer const *)arg1)->GetId();
8612
8613 wxPyEndAllowThreads(__tstate);
8614 if (PyErr_Occurred()) SWIG_fail;
8615 }
8616 {
8617 resultobj = SWIG_From_int((int)(result));
8618 }
8619 return resultobj;
8620 fail:
8621 return NULL;
8622 }
8623
8624
8625 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8626 PyObject *obj;
8627 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8628 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8629 Py_INCREF(obj);
8630 return Py_BuildValue((char *)"");
8631 }
8632 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8633 PyObject *resultobj;
8634 int arg1 = (int) 0 ;
8635 int arg2 = (int) 0 ;
8636 wxTimerEvent *result;
8637 PyObject * obj0 = 0 ;
8638 PyObject * obj1 = 0 ;
8639 char *kwnames[] = {
8640 (char *) "timerid",(char *) "interval", NULL
8641 };
8642
8643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8644 if (obj0) {
8645 {
8646 arg1 = (int)(SWIG_As_int(obj0));
8647 if (SWIG_arg_fail(1)) SWIG_fail;
8648 }
8649 }
8650 if (obj1) {
8651 {
8652 arg2 = (int)(SWIG_As_int(obj1));
8653 if (SWIG_arg_fail(2)) SWIG_fail;
8654 }
8655 }
8656 {
8657 PyThreadState* __tstate = wxPyBeginAllowThreads();
8658 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8659
8660 wxPyEndAllowThreads(__tstate);
8661 if (PyErr_Occurred()) SWIG_fail;
8662 }
8663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8664 return resultobj;
8665 fail:
8666 return NULL;
8667 }
8668
8669
8670 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8671 PyObject *resultobj;
8672 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8673 int result;
8674 PyObject * obj0 = 0 ;
8675 char *kwnames[] = {
8676 (char *) "self", NULL
8677 };
8678
8679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8681 if (SWIG_arg_fail(1)) SWIG_fail;
8682 {
8683 PyThreadState* __tstate = wxPyBeginAllowThreads();
8684 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8685
8686 wxPyEndAllowThreads(__tstate);
8687 if (PyErr_Occurred()) SWIG_fail;
8688 }
8689 {
8690 resultobj = SWIG_From_int((int)(result));
8691 }
8692 return resultobj;
8693 fail:
8694 return NULL;
8695 }
8696
8697
8698 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8699 PyObject *obj;
8700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8701 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8702 Py_INCREF(obj);
8703 return Py_BuildValue((char *)"");
8704 }
8705 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8706 PyObject *resultobj;
8707 wxTimer *arg1 = 0 ;
8708 wxTimerRunner *result;
8709 PyObject * obj0 = 0 ;
8710
8711 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8712 {
8713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8714 if (SWIG_arg_fail(1)) SWIG_fail;
8715 if (arg1 == NULL) {
8716 SWIG_null_ref("wxTimer");
8717 }
8718 if (SWIG_arg_fail(1)) SWIG_fail;
8719 }
8720 {
8721 if (!wxPyCheckForApp()) SWIG_fail;
8722 PyThreadState* __tstate = wxPyBeginAllowThreads();
8723 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8724
8725 wxPyEndAllowThreads(__tstate);
8726 if (PyErr_Occurred()) SWIG_fail;
8727 }
8728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8729 return resultobj;
8730 fail:
8731 return NULL;
8732 }
8733
8734
8735 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8736 PyObject *resultobj;
8737 wxTimer *arg1 = 0 ;
8738 int arg2 ;
8739 bool arg3 = (bool) false ;
8740 wxTimerRunner *result;
8741 PyObject * obj0 = 0 ;
8742 PyObject * obj1 = 0 ;
8743 PyObject * obj2 = 0 ;
8744
8745 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8746 {
8747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8748 if (SWIG_arg_fail(1)) SWIG_fail;
8749 if (arg1 == NULL) {
8750 SWIG_null_ref("wxTimer");
8751 }
8752 if (SWIG_arg_fail(1)) SWIG_fail;
8753 }
8754 {
8755 arg2 = (int)(SWIG_As_int(obj1));
8756 if (SWIG_arg_fail(2)) SWIG_fail;
8757 }
8758 if (obj2) {
8759 {
8760 arg3 = (bool)(SWIG_As_bool(obj2));
8761 if (SWIG_arg_fail(3)) SWIG_fail;
8762 }
8763 }
8764 {
8765 if (!wxPyCheckForApp()) SWIG_fail;
8766 PyThreadState* __tstate = wxPyBeginAllowThreads();
8767 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8768
8769 wxPyEndAllowThreads(__tstate);
8770 if (PyErr_Occurred()) SWIG_fail;
8771 }
8772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8773 return resultobj;
8774 fail:
8775 return NULL;
8776 }
8777
8778
8779 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8780 int argc;
8781 PyObject *argv[4];
8782 int ii;
8783
8784 argc = PyObject_Length(args);
8785 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8786 argv[ii] = PyTuple_GetItem(args,ii);
8787 }
8788 if (argc == 1) {
8789 int _v;
8790 {
8791 void *ptr = 0;
8792 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8793 _v = 0;
8794 PyErr_Clear();
8795 } else {
8796 _v = (ptr != 0);
8797 }
8798 }
8799 if (_v) {
8800 return _wrap_new_TimerRunner__SWIG_0(self,args);
8801 }
8802 }
8803 if ((argc >= 2) && (argc <= 3)) {
8804 int _v;
8805 {
8806 void *ptr = 0;
8807 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8808 _v = 0;
8809 PyErr_Clear();
8810 } else {
8811 _v = (ptr != 0);
8812 }
8813 }
8814 if (_v) {
8815 _v = SWIG_Check_int(argv[1]);
8816 if (_v) {
8817 if (argc <= 2) {
8818 return _wrap_new_TimerRunner__SWIG_1(self,args);
8819 }
8820 _v = SWIG_Check_bool(argv[2]);
8821 if (_v) {
8822 return _wrap_new_TimerRunner__SWIG_1(self,args);
8823 }
8824 }
8825 }
8826 }
8827
8828 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8829 return NULL;
8830 }
8831
8832
8833 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8834 PyObject *resultobj;
8835 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8836 PyObject * obj0 = 0 ;
8837 char *kwnames[] = {
8838 (char *) "self", NULL
8839 };
8840
8841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8843 if (SWIG_arg_fail(1)) SWIG_fail;
8844 {
8845 PyThreadState* __tstate = wxPyBeginAllowThreads();
8846 delete arg1;
8847
8848 wxPyEndAllowThreads(__tstate);
8849 if (PyErr_Occurred()) SWIG_fail;
8850 }
8851 Py_INCREF(Py_None); resultobj = Py_None;
8852 return resultobj;
8853 fail:
8854 return NULL;
8855 }
8856
8857
8858 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8859 PyObject *resultobj;
8860 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8861 int arg2 ;
8862 bool arg3 = (bool) false ;
8863 PyObject * obj0 = 0 ;
8864 PyObject * obj1 = 0 ;
8865 PyObject * obj2 = 0 ;
8866 char *kwnames[] = {
8867 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8868 };
8869
8870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8872 if (SWIG_arg_fail(1)) SWIG_fail;
8873 {
8874 arg2 = (int)(SWIG_As_int(obj1));
8875 if (SWIG_arg_fail(2)) SWIG_fail;
8876 }
8877 if (obj2) {
8878 {
8879 arg3 = (bool)(SWIG_As_bool(obj2));
8880 if (SWIG_arg_fail(3)) SWIG_fail;
8881 }
8882 }
8883 {
8884 PyThreadState* __tstate = wxPyBeginAllowThreads();
8885 (arg1)->Start(arg2,arg3);
8886
8887 wxPyEndAllowThreads(__tstate);
8888 if (PyErr_Occurred()) SWIG_fail;
8889 }
8890 Py_INCREF(Py_None); resultobj = Py_None;
8891 return resultobj;
8892 fail:
8893 return NULL;
8894 }
8895
8896
8897 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8898 PyObject *obj;
8899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8900 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8901 Py_INCREF(obj);
8902 return Py_BuildValue((char *)"");
8903 }
8904 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8905 PyObject *resultobj;
8906 wxLog *result;
8907 char *kwnames[] = {
8908 NULL
8909 };
8910
8911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8912 {
8913 PyThreadState* __tstate = wxPyBeginAllowThreads();
8914 result = (wxLog *)new wxLog();
8915
8916 wxPyEndAllowThreads(__tstate);
8917 if (PyErr_Occurred()) SWIG_fail;
8918 }
8919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8920 return resultobj;
8921 fail:
8922 return NULL;
8923 }
8924
8925
8926 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8927 PyObject *resultobj;
8928 bool result;
8929 char *kwnames[] = {
8930 NULL
8931 };
8932
8933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8934 {
8935 PyThreadState* __tstate = wxPyBeginAllowThreads();
8936 result = (bool)wxLog::IsEnabled();
8937
8938 wxPyEndAllowThreads(__tstate);
8939 if (PyErr_Occurred()) SWIG_fail;
8940 }
8941 {
8942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8943 }
8944 return resultobj;
8945 fail:
8946 return NULL;
8947 }
8948
8949
8950 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8951 PyObject *resultobj;
8952 bool arg1 = (bool) true ;
8953 bool result;
8954 PyObject * obj0 = 0 ;
8955 char *kwnames[] = {
8956 (char *) "doIt", NULL
8957 };
8958
8959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8960 if (obj0) {
8961 {
8962 arg1 = (bool)(SWIG_As_bool(obj0));
8963 if (SWIG_arg_fail(1)) SWIG_fail;
8964 }
8965 }
8966 {
8967 PyThreadState* __tstate = wxPyBeginAllowThreads();
8968 result = (bool)wxLog::EnableLogging(arg1);
8969
8970 wxPyEndAllowThreads(__tstate);
8971 if (PyErr_Occurred()) SWIG_fail;
8972 }
8973 {
8974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8975 }
8976 return resultobj;
8977 fail:
8978 return NULL;
8979 }
8980
8981
8982 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8983 PyObject *resultobj;
8984 wxLogLevel arg1 ;
8985 wxChar *arg2 = (wxChar *) 0 ;
8986 time_t arg3 ;
8987 PyObject * obj0 = 0 ;
8988 PyObject * obj1 = 0 ;
8989 PyObject * obj2 = 0 ;
8990 char *kwnames[] = {
8991 (char *) "level",(char *) "szString",(char *) "t", NULL
8992 };
8993
8994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8995 {
8996 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8997 if (SWIG_arg_fail(1)) SWIG_fail;
8998 }
8999 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9000 if (SWIG_arg_fail(2)) SWIG_fail;
9001 {
9002 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
9003 if (SWIG_arg_fail(3)) SWIG_fail;
9004 }
9005 {
9006 PyThreadState* __tstate = wxPyBeginAllowThreads();
9007 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
9008
9009 wxPyEndAllowThreads(__tstate);
9010 if (PyErr_Occurred()) SWIG_fail;
9011 }
9012 Py_INCREF(Py_None); resultobj = Py_None;
9013 return resultobj;
9014 fail:
9015 return NULL;
9016 }
9017
9018
9019 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
9020 PyObject *resultobj;
9021 wxLog *arg1 = (wxLog *) 0 ;
9022 PyObject * obj0 = 0 ;
9023 char *kwnames[] = {
9024 (char *) "self", NULL
9025 };
9026
9027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
9028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9029 if (SWIG_arg_fail(1)) SWIG_fail;
9030 {
9031 PyThreadState* __tstate = wxPyBeginAllowThreads();
9032 (arg1)->Flush();
9033
9034 wxPyEndAllowThreads(__tstate);
9035 if (PyErr_Occurred()) SWIG_fail;
9036 }
9037 Py_INCREF(Py_None); resultobj = Py_None;
9038 return resultobj;
9039 fail:
9040 return NULL;
9041 }
9042
9043
9044 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9045 PyObject *resultobj;
9046 char *kwnames[] = {
9047 NULL
9048 };
9049
9050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9051 {
9052 PyThreadState* __tstate = wxPyBeginAllowThreads();
9053 wxLog::FlushActive();
9054
9055 wxPyEndAllowThreads(__tstate);
9056 if (PyErr_Occurred()) SWIG_fail;
9057 }
9058 Py_INCREF(Py_None); resultobj = Py_None;
9059 return resultobj;
9060 fail:
9061 return NULL;
9062 }
9063
9064
9065 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9066 PyObject *resultobj;
9067 wxLog *result;
9068 char *kwnames[] = {
9069 NULL
9070 };
9071
9072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9073 {
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 result = (wxLog *)wxLog::GetActiveTarget();
9076
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9081 return resultobj;
9082 fail:
9083 return NULL;
9084 }
9085
9086
9087 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9088 PyObject *resultobj;
9089 wxLog *arg1 = (wxLog *) 0 ;
9090 wxLog *result;
9091 PyObject * obj0 = 0 ;
9092 char *kwnames[] = {
9093 (char *) "pLogger", NULL
9094 };
9095
9096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9098 if (SWIG_arg_fail(1)) SWIG_fail;
9099 {
9100 PyThreadState* __tstate = wxPyBeginAllowThreads();
9101 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9102
9103 wxPyEndAllowThreads(__tstate);
9104 if (PyErr_Occurred()) SWIG_fail;
9105 }
9106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9107 return resultobj;
9108 fail:
9109 return NULL;
9110 }
9111
9112
9113 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9114 PyObject *resultobj;
9115 char *kwnames[] = {
9116 NULL
9117 };
9118
9119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9120 {
9121 PyThreadState* __tstate = wxPyBeginAllowThreads();
9122 wxLog::Suspend();
9123
9124 wxPyEndAllowThreads(__tstate);
9125 if (PyErr_Occurred()) SWIG_fail;
9126 }
9127 Py_INCREF(Py_None); resultobj = Py_None;
9128 return resultobj;
9129 fail:
9130 return NULL;
9131 }
9132
9133
9134 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9135 PyObject *resultobj;
9136 char *kwnames[] = {
9137 NULL
9138 };
9139
9140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9141 {
9142 PyThreadState* __tstate = wxPyBeginAllowThreads();
9143 wxLog::Resume();
9144
9145 wxPyEndAllowThreads(__tstate);
9146 if (PyErr_Occurred()) SWIG_fail;
9147 }
9148 Py_INCREF(Py_None); resultobj = Py_None;
9149 return resultobj;
9150 fail:
9151 return NULL;
9152 }
9153
9154
9155 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9156 PyObject *resultobj;
9157 bool arg1 = (bool) true ;
9158 PyObject * obj0 = 0 ;
9159 char *kwnames[] = {
9160 (char *) "bVerbose", NULL
9161 };
9162
9163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9164 if (obj0) {
9165 {
9166 arg1 = (bool)(SWIG_As_bool(obj0));
9167 if (SWIG_arg_fail(1)) SWIG_fail;
9168 }
9169 }
9170 {
9171 PyThreadState* __tstate = wxPyBeginAllowThreads();
9172 wxLog::SetVerbose(arg1);
9173
9174 wxPyEndAllowThreads(__tstate);
9175 if (PyErr_Occurred()) SWIG_fail;
9176 }
9177 Py_INCREF(Py_None); resultobj = Py_None;
9178 return resultobj;
9179 fail:
9180 return NULL;
9181 }
9182
9183
9184 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9185 PyObject *resultobj;
9186 wxLogLevel arg1 ;
9187 PyObject * obj0 = 0 ;
9188 char *kwnames[] = {
9189 (char *) "logLevel", NULL
9190 };
9191
9192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9193 {
9194 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9195 if (SWIG_arg_fail(1)) SWIG_fail;
9196 }
9197 {
9198 PyThreadState* __tstate = wxPyBeginAllowThreads();
9199 wxLog::SetLogLevel(arg1);
9200
9201 wxPyEndAllowThreads(__tstate);
9202 if (PyErr_Occurred()) SWIG_fail;
9203 }
9204 Py_INCREF(Py_None); resultobj = Py_None;
9205 return resultobj;
9206 fail:
9207 return NULL;
9208 }
9209
9210
9211 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9212 PyObject *resultobj;
9213 char *kwnames[] = {
9214 NULL
9215 };
9216
9217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9218 {
9219 PyThreadState* __tstate = wxPyBeginAllowThreads();
9220 wxLog::DontCreateOnDemand();
9221
9222 wxPyEndAllowThreads(__tstate);
9223 if (PyErr_Occurred()) SWIG_fail;
9224 }
9225 Py_INCREF(Py_None); resultobj = Py_None;
9226 return resultobj;
9227 fail:
9228 return NULL;
9229 }
9230
9231
9232 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9233 PyObject *resultobj;
9234 wxTraceMask arg1 ;
9235 PyObject * obj0 = 0 ;
9236 char *kwnames[] = {
9237 (char *) "ulMask", NULL
9238 };
9239
9240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9241 {
9242 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9243 if (SWIG_arg_fail(1)) SWIG_fail;
9244 }
9245 {
9246 PyThreadState* __tstate = wxPyBeginAllowThreads();
9247 wxLog::SetTraceMask(arg1);
9248
9249 wxPyEndAllowThreads(__tstate);
9250 if (PyErr_Occurred()) SWIG_fail;
9251 }
9252 Py_INCREF(Py_None); resultobj = Py_None;
9253 return resultobj;
9254 fail:
9255 return NULL;
9256 }
9257
9258
9259 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9260 PyObject *resultobj;
9261 wxString *arg1 = 0 ;
9262 bool temp1 = false ;
9263 PyObject * obj0 = 0 ;
9264 char *kwnames[] = {
9265 (char *) "str", NULL
9266 };
9267
9268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9269 {
9270 arg1 = wxString_in_helper(obj0);
9271 if (arg1 == NULL) SWIG_fail;
9272 temp1 = true;
9273 }
9274 {
9275 PyThreadState* __tstate = wxPyBeginAllowThreads();
9276 wxLog::AddTraceMask((wxString const &)*arg1);
9277
9278 wxPyEndAllowThreads(__tstate);
9279 if (PyErr_Occurred()) SWIG_fail;
9280 }
9281 Py_INCREF(Py_None); resultobj = Py_None;
9282 {
9283 if (temp1)
9284 delete arg1;
9285 }
9286 return resultobj;
9287 fail:
9288 {
9289 if (temp1)
9290 delete arg1;
9291 }
9292 return NULL;
9293 }
9294
9295
9296 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9297 PyObject *resultobj;
9298 wxString *arg1 = 0 ;
9299 bool temp1 = false ;
9300 PyObject * obj0 = 0 ;
9301 char *kwnames[] = {
9302 (char *) "str", NULL
9303 };
9304
9305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9306 {
9307 arg1 = wxString_in_helper(obj0);
9308 if (arg1 == NULL) SWIG_fail;
9309 temp1 = true;
9310 }
9311 {
9312 PyThreadState* __tstate = wxPyBeginAllowThreads();
9313 wxLog::RemoveTraceMask((wxString const &)*arg1);
9314
9315 wxPyEndAllowThreads(__tstate);
9316 if (PyErr_Occurred()) SWIG_fail;
9317 }
9318 Py_INCREF(Py_None); resultobj = Py_None;
9319 {
9320 if (temp1)
9321 delete arg1;
9322 }
9323 return resultobj;
9324 fail:
9325 {
9326 if (temp1)
9327 delete arg1;
9328 }
9329 return NULL;
9330 }
9331
9332
9333 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9334 PyObject *resultobj;
9335 char *kwnames[] = {
9336 NULL
9337 };
9338
9339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9340 {
9341 PyThreadState* __tstate = wxPyBeginAllowThreads();
9342 wxLog::ClearTraceMasks();
9343
9344 wxPyEndAllowThreads(__tstate);
9345 if (PyErr_Occurred()) SWIG_fail;
9346 }
9347 Py_INCREF(Py_None); resultobj = Py_None;
9348 return resultobj;
9349 fail:
9350 return NULL;
9351 }
9352
9353
9354 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9355 PyObject *resultobj;
9356 wxArrayString *result;
9357 char *kwnames[] = {
9358 NULL
9359 };
9360
9361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9362 {
9363 PyThreadState* __tstate = wxPyBeginAllowThreads();
9364 {
9365 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9366 result = (wxArrayString *) &_result_ref;
9367 }
9368
9369 wxPyEndAllowThreads(__tstate);
9370 if (PyErr_Occurred()) SWIG_fail;
9371 }
9372 {
9373 resultobj = wxArrayString2PyList_helper(*result);
9374 }
9375 return resultobj;
9376 fail:
9377 return NULL;
9378 }
9379
9380
9381 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9382 PyObject *resultobj;
9383 wxChar *arg1 = (wxChar *) 0 ;
9384 PyObject * obj0 = 0 ;
9385 char *kwnames[] = {
9386 (char *) "ts", NULL
9387 };
9388
9389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9391 if (SWIG_arg_fail(1)) SWIG_fail;
9392 {
9393 PyThreadState* __tstate = wxPyBeginAllowThreads();
9394 wxLog::SetTimestamp((wxChar const *)arg1);
9395
9396 wxPyEndAllowThreads(__tstate);
9397 if (PyErr_Occurred()) SWIG_fail;
9398 }
9399 Py_INCREF(Py_None); resultobj = Py_None;
9400 return resultobj;
9401 fail:
9402 return NULL;
9403 }
9404
9405
9406 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9407 PyObject *resultobj;
9408 bool result;
9409 char *kwnames[] = {
9410 NULL
9411 };
9412
9413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9414 {
9415 PyThreadState* __tstate = wxPyBeginAllowThreads();
9416 result = (bool)wxLog::GetVerbose();
9417
9418 wxPyEndAllowThreads(__tstate);
9419 if (PyErr_Occurred()) SWIG_fail;
9420 }
9421 {
9422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9423 }
9424 return resultobj;
9425 fail:
9426 return NULL;
9427 }
9428
9429
9430 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9431 PyObject *resultobj;
9432 wxTraceMask result;
9433 char *kwnames[] = {
9434 NULL
9435 };
9436
9437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9438 {
9439 PyThreadState* __tstate = wxPyBeginAllowThreads();
9440 result = (wxTraceMask)wxLog::GetTraceMask();
9441
9442 wxPyEndAllowThreads(__tstate);
9443 if (PyErr_Occurred()) SWIG_fail;
9444 }
9445 {
9446 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9447 }
9448 return resultobj;
9449 fail:
9450 return NULL;
9451 }
9452
9453
9454 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9455 PyObject *resultobj;
9456 wxChar *arg1 = (wxChar *) 0 ;
9457 bool result;
9458 PyObject * obj0 = 0 ;
9459 char *kwnames[] = {
9460 (char *) "mask", NULL
9461 };
9462
9463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9465 if (SWIG_arg_fail(1)) SWIG_fail;
9466 {
9467 PyThreadState* __tstate = wxPyBeginAllowThreads();
9468 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9469
9470 wxPyEndAllowThreads(__tstate);
9471 if (PyErr_Occurred()) SWIG_fail;
9472 }
9473 {
9474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9475 }
9476 return resultobj;
9477 fail:
9478 return NULL;
9479 }
9480
9481
9482 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9483 PyObject *resultobj;
9484 wxLogLevel result;
9485 char *kwnames[] = {
9486 NULL
9487 };
9488
9489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9490 {
9491 PyThreadState* __tstate = wxPyBeginAllowThreads();
9492 result = (wxLogLevel)wxLog::GetLogLevel();
9493
9494 wxPyEndAllowThreads(__tstate);
9495 if (PyErr_Occurred()) SWIG_fail;
9496 }
9497 {
9498 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9499 }
9500 return resultobj;
9501 fail:
9502 return NULL;
9503 }
9504
9505
9506 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9507 PyObject *resultobj;
9508 wxChar *result;
9509 char *kwnames[] = {
9510 NULL
9511 };
9512
9513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9514 {
9515 PyThreadState* __tstate = wxPyBeginAllowThreads();
9516 result = (wxChar *)wxLog::GetTimestamp();
9517
9518 wxPyEndAllowThreads(__tstate);
9519 if (PyErr_Occurred()) SWIG_fail;
9520 }
9521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9522 return resultobj;
9523 fail:
9524 return NULL;
9525 }
9526
9527
9528 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9529 PyObject *resultobj;
9530 wxString result;
9531 char *kwnames[] = {
9532 NULL
9533 };
9534
9535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9536 {
9537 PyThreadState* __tstate = wxPyBeginAllowThreads();
9538 result = Log_TimeStamp();
9539
9540 wxPyEndAllowThreads(__tstate);
9541 if (PyErr_Occurred()) SWIG_fail;
9542 }
9543 {
9544 #if wxUSE_UNICODE
9545 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9546 #else
9547 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9548 #endif
9549 }
9550 return resultobj;
9551 fail:
9552 return NULL;
9553 }
9554
9555
9556 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9557 PyObject *resultobj;
9558 wxLog *arg1 = (wxLog *) 0 ;
9559 PyObject * obj0 = 0 ;
9560 char *kwnames[] = {
9561 (char *) "self", NULL
9562 };
9563
9564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9566 if (SWIG_arg_fail(1)) SWIG_fail;
9567 {
9568 PyThreadState* __tstate = wxPyBeginAllowThreads();
9569 wxLog_Destroy(arg1);
9570
9571 wxPyEndAllowThreads(__tstate);
9572 if (PyErr_Occurred()) SWIG_fail;
9573 }
9574 Py_INCREF(Py_None); resultobj = Py_None;
9575 return resultobj;
9576 fail:
9577 return NULL;
9578 }
9579
9580
9581 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9582 PyObject *obj;
9583 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9584 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9585 Py_INCREF(obj);
9586 return Py_BuildValue((char *)"");
9587 }
9588 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9589 PyObject *resultobj;
9590 wxLogStderr *result;
9591 char *kwnames[] = {
9592 NULL
9593 };
9594
9595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9596 {
9597 PyThreadState* __tstate = wxPyBeginAllowThreads();
9598 result = (wxLogStderr *)new wxLogStderr();
9599
9600 wxPyEndAllowThreads(__tstate);
9601 if (PyErr_Occurred()) SWIG_fail;
9602 }
9603 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9604 return resultobj;
9605 fail:
9606 return NULL;
9607 }
9608
9609
9610 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9611 PyObject *obj;
9612 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9613 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9614 Py_INCREF(obj);
9615 return Py_BuildValue((char *)"");
9616 }
9617 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9618 PyObject *resultobj;
9619 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9620 wxLogTextCtrl *result;
9621 PyObject * obj0 = 0 ;
9622 char *kwnames[] = {
9623 (char *) "pTextCtrl", NULL
9624 };
9625
9626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9628 if (SWIG_arg_fail(1)) SWIG_fail;
9629 {
9630 PyThreadState* __tstate = wxPyBeginAllowThreads();
9631 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9632
9633 wxPyEndAllowThreads(__tstate);
9634 if (PyErr_Occurred()) SWIG_fail;
9635 }
9636 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9637 return resultobj;
9638 fail:
9639 return NULL;
9640 }
9641
9642
9643 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9644 PyObject *obj;
9645 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9646 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9647 Py_INCREF(obj);
9648 return Py_BuildValue((char *)"");
9649 }
9650 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9651 PyObject *resultobj;
9652 wxLogGui *result;
9653 char *kwnames[] = {
9654 NULL
9655 };
9656
9657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9658 {
9659 PyThreadState* __tstate = wxPyBeginAllowThreads();
9660 result = (wxLogGui *)new wxLogGui();
9661
9662 wxPyEndAllowThreads(__tstate);
9663 if (PyErr_Occurred()) SWIG_fail;
9664 }
9665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9666 return resultobj;
9667 fail:
9668 return NULL;
9669 }
9670
9671
9672 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9673 PyObject *obj;
9674 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9675 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9676 Py_INCREF(obj);
9677 return Py_BuildValue((char *)"");
9678 }
9679 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9680 PyObject *resultobj;
9681 wxFrame *arg1 = (wxFrame *) 0 ;
9682 wxString *arg2 = 0 ;
9683 bool arg3 = (bool) true ;
9684 bool arg4 = (bool) true ;
9685 wxLogWindow *result;
9686 bool temp2 = false ;
9687 PyObject * obj0 = 0 ;
9688 PyObject * obj1 = 0 ;
9689 PyObject * obj2 = 0 ;
9690 PyObject * obj3 = 0 ;
9691 char *kwnames[] = {
9692 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9693 };
9694
9695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9697 if (SWIG_arg_fail(1)) SWIG_fail;
9698 {
9699 arg2 = wxString_in_helper(obj1);
9700 if (arg2 == NULL) SWIG_fail;
9701 temp2 = true;
9702 }
9703 if (obj2) {
9704 {
9705 arg3 = (bool)(SWIG_As_bool(obj2));
9706 if (SWIG_arg_fail(3)) SWIG_fail;
9707 }
9708 }
9709 if (obj3) {
9710 {
9711 arg4 = (bool)(SWIG_As_bool(obj3));
9712 if (SWIG_arg_fail(4)) SWIG_fail;
9713 }
9714 }
9715 {
9716 PyThreadState* __tstate = wxPyBeginAllowThreads();
9717 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9718
9719 wxPyEndAllowThreads(__tstate);
9720 if (PyErr_Occurred()) SWIG_fail;
9721 }
9722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9723 {
9724 if (temp2)
9725 delete arg2;
9726 }
9727 return resultobj;
9728 fail:
9729 {
9730 if (temp2)
9731 delete arg2;
9732 }
9733 return NULL;
9734 }
9735
9736
9737 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9738 PyObject *resultobj;
9739 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9740 bool arg2 = (bool) true ;
9741 PyObject * obj0 = 0 ;
9742 PyObject * obj1 = 0 ;
9743 char *kwnames[] = {
9744 (char *) "self",(char *) "bShow", NULL
9745 };
9746
9747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9749 if (SWIG_arg_fail(1)) SWIG_fail;
9750 if (obj1) {
9751 {
9752 arg2 = (bool)(SWIG_As_bool(obj1));
9753 if (SWIG_arg_fail(2)) SWIG_fail;
9754 }
9755 }
9756 {
9757 PyThreadState* __tstate = wxPyBeginAllowThreads();
9758 (arg1)->Show(arg2);
9759
9760 wxPyEndAllowThreads(__tstate);
9761 if (PyErr_Occurred()) SWIG_fail;
9762 }
9763 Py_INCREF(Py_None); resultobj = Py_None;
9764 return resultobj;
9765 fail:
9766 return NULL;
9767 }
9768
9769
9770 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9771 PyObject *resultobj;
9772 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9773 wxFrame *result;
9774 PyObject * obj0 = 0 ;
9775 char *kwnames[] = {
9776 (char *) "self", NULL
9777 };
9778
9779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9781 if (SWIG_arg_fail(1)) SWIG_fail;
9782 {
9783 PyThreadState* __tstate = wxPyBeginAllowThreads();
9784 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9785
9786 wxPyEndAllowThreads(__tstate);
9787 if (PyErr_Occurred()) SWIG_fail;
9788 }
9789 {
9790 resultobj = wxPyMake_wxObject(result, 0);
9791 }
9792 return resultobj;
9793 fail:
9794 return NULL;
9795 }
9796
9797
9798 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9799 PyObject *resultobj;
9800 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9801 wxLog *result;
9802 PyObject * obj0 = 0 ;
9803 char *kwnames[] = {
9804 (char *) "self", NULL
9805 };
9806
9807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9809 if (SWIG_arg_fail(1)) SWIG_fail;
9810 {
9811 PyThreadState* __tstate = wxPyBeginAllowThreads();
9812 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9813
9814 wxPyEndAllowThreads(__tstate);
9815 if (PyErr_Occurred()) SWIG_fail;
9816 }
9817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9818 return resultobj;
9819 fail:
9820 return NULL;
9821 }
9822
9823
9824 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9825 PyObject *resultobj;
9826 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9827 bool result;
9828 PyObject * obj0 = 0 ;
9829 char *kwnames[] = {
9830 (char *) "self", NULL
9831 };
9832
9833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9835 if (SWIG_arg_fail(1)) SWIG_fail;
9836 {
9837 PyThreadState* __tstate = wxPyBeginAllowThreads();
9838 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9839
9840 wxPyEndAllowThreads(__tstate);
9841 if (PyErr_Occurred()) SWIG_fail;
9842 }
9843 {
9844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9845 }
9846 return resultobj;
9847 fail:
9848 return NULL;
9849 }
9850
9851
9852 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9853 PyObject *resultobj;
9854 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9855 bool arg2 ;
9856 PyObject * obj0 = 0 ;
9857 PyObject * obj1 = 0 ;
9858 char *kwnames[] = {
9859 (char *) "self",(char *) "bDoPass", NULL
9860 };
9861
9862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9864 if (SWIG_arg_fail(1)) SWIG_fail;
9865 {
9866 arg2 = (bool)(SWIG_As_bool(obj1));
9867 if (SWIG_arg_fail(2)) SWIG_fail;
9868 }
9869 {
9870 PyThreadState* __tstate = wxPyBeginAllowThreads();
9871 (arg1)->PassMessages(arg2);
9872
9873 wxPyEndAllowThreads(__tstate);
9874 if (PyErr_Occurred()) SWIG_fail;
9875 }
9876 Py_INCREF(Py_None); resultobj = Py_None;
9877 return resultobj;
9878 fail:
9879 return NULL;
9880 }
9881
9882
9883 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9884 PyObject *obj;
9885 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9886 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9887 Py_INCREF(obj);
9888 return Py_BuildValue((char *)"");
9889 }
9890 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9891 PyObject *resultobj;
9892 wxLog *arg1 = (wxLog *) 0 ;
9893 wxLogChain *result;
9894 PyObject * obj0 = 0 ;
9895 char *kwnames[] = {
9896 (char *) "logger", NULL
9897 };
9898
9899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9901 if (SWIG_arg_fail(1)) SWIG_fail;
9902 {
9903 PyThreadState* __tstate = wxPyBeginAllowThreads();
9904 result = (wxLogChain *)new wxLogChain(arg1);
9905
9906 wxPyEndAllowThreads(__tstate);
9907 if (PyErr_Occurred()) SWIG_fail;
9908 }
9909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9910 return resultobj;
9911 fail:
9912 return NULL;
9913 }
9914
9915
9916 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9917 PyObject *resultobj;
9918 wxLogChain *arg1 = (wxLogChain *) 0 ;
9919 wxLog *arg2 = (wxLog *) 0 ;
9920 PyObject * obj0 = 0 ;
9921 PyObject * obj1 = 0 ;
9922 char *kwnames[] = {
9923 (char *) "self",(char *) "logger", NULL
9924 };
9925
9926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9928 if (SWIG_arg_fail(1)) SWIG_fail;
9929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9930 if (SWIG_arg_fail(2)) SWIG_fail;
9931 {
9932 PyThreadState* __tstate = wxPyBeginAllowThreads();
9933 (arg1)->SetLog(arg2);
9934
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 Py_INCREF(Py_None); resultobj = Py_None;
9939 return resultobj;
9940 fail:
9941 return NULL;
9942 }
9943
9944
9945 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9946 PyObject *resultobj;
9947 wxLogChain *arg1 = (wxLogChain *) 0 ;
9948 bool arg2 ;
9949 PyObject * obj0 = 0 ;
9950 PyObject * obj1 = 0 ;
9951 char *kwnames[] = {
9952 (char *) "self",(char *) "bDoPass", NULL
9953 };
9954
9955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9957 if (SWIG_arg_fail(1)) SWIG_fail;
9958 {
9959 arg2 = (bool)(SWIG_As_bool(obj1));
9960 if (SWIG_arg_fail(2)) SWIG_fail;
9961 }
9962 {
9963 PyThreadState* __tstate = wxPyBeginAllowThreads();
9964 (arg1)->PassMessages(arg2);
9965
9966 wxPyEndAllowThreads(__tstate);
9967 if (PyErr_Occurred()) SWIG_fail;
9968 }
9969 Py_INCREF(Py_None); resultobj = Py_None;
9970 return resultobj;
9971 fail:
9972 return NULL;
9973 }
9974
9975
9976 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9977 PyObject *resultobj;
9978 wxLogChain *arg1 = (wxLogChain *) 0 ;
9979 bool result;
9980 PyObject * obj0 = 0 ;
9981 char *kwnames[] = {
9982 (char *) "self", NULL
9983 };
9984
9985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9987 if (SWIG_arg_fail(1)) SWIG_fail;
9988 {
9989 PyThreadState* __tstate = wxPyBeginAllowThreads();
9990 result = (bool)(arg1)->IsPassingMessages();
9991
9992 wxPyEndAllowThreads(__tstate);
9993 if (PyErr_Occurred()) SWIG_fail;
9994 }
9995 {
9996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9997 }
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10005 PyObject *resultobj;
10006 wxLogChain *arg1 = (wxLogChain *) 0 ;
10007 wxLog *result;
10008 PyObject * obj0 = 0 ;
10009 char *kwnames[] = {
10010 (char *) "self", NULL
10011 };
10012
10013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
10014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10015 if (SWIG_arg_fail(1)) SWIG_fail;
10016 {
10017 PyThreadState* __tstate = wxPyBeginAllowThreads();
10018 result = (wxLog *)(arg1)->GetOldLog();
10019
10020 wxPyEndAllowThreads(__tstate);
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10024 return resultobj;
10025 fail:
10026 return NULL;
10027 }
10028
10029
10030 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
10031 PyObject *obj;
10032 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10033 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10034 Py_INCREF(obj);
10035 return Py_BuildValue((char *)"");
10036 }
10037 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10038 PyObject *resultobj;
10039 unsigned long result;
10040 char *kwnames[] = {
10041 NULL
10042 };
10043
10044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10045 {
10046 PyThreadState* __tstate = wxPyBeginAllowThreads();
10047 result = (unsigned long)wxSysErrorCode();
10048
10049 wxPyEndAllowThreads(__tstate);
10050 if (PyErr_Occurred()) SWIG_fail;
10051 }
10052 {
10053 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10054 }
10055 return resultobj;
10056 fail:
10057 return NULL;
10058 }
10059
10060
10061 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10062 PyObject *resultobj;
10063 unsigned long arg1 = (unsigned long) 0 ;
10064 wxString result;
10065 PyObject * obj0 = 0 ;
10066 char *kwnames[] = {
10067 (char *) "nErrCode", NULL
10068 };
10069
10070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10071 if (obj0) {
10072 {
10073 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10074 if (SWIG_arg_fail(1)) SWIG_fail;
10075 }
10076 }
10077 {
10078 PyThreadState* __tstate = wxPyBeginAllowThreads();
10079 result = wxSysErrorMsg(arg1);
10080
10081 wxPyEndAllowThreads(__tstate);
10082 if (PyErr_Occurred()) SWIG_fail;
10083 }
10084 {
10085 #if wxUSE_UNICODE
10086 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10087 #else
10088 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10089 #endif
10090 }
10091 return resultobj;
10092 fail:
10093 return NULL;
10094 }
10095
10096
10097 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10098 PyObject *resultobj;
10099 wxString *arg1 = 0 ;
10100 bool temp1 = false ;
10101 PyObject * obj0 = 0 ;
10102 char *kwnames[] = {
10103 (char *) "msg", NULL
10104 };
10105
10106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10107 {
10108 arg1 = wxString_in_helper(obj0);
10109 if (arg1 == NULL) SWIG_fail;
10110 temp1 = true;
10111 }
10112 {
10113 PyThreadState* __tstate = wxPyBeginAllowThreads();
10114 wxPyLogFatalError((wxString const &)*arg1);
10115
10116 wxPyEndAllowThreads(__tstate);
10117 if (PyErr_Occurred()) SWIG_fail;
10118 }
10119 Py_INCREF(Py_None); resultobj = Py_None;
10120 {
10121 if (temp1)
10122 delete arg1;
10123 }
10124 return resultobj;
10125 fail:
10126 {
10127 if (temp1)
10128 delete arg1;
10129 }
10130 return NULL;
10131 }
10132
10133
10134 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10135 PyObject *resultobj;
10136 wxString *arg1 = 0 ;
10137 bool temp1 = false ;
10138 PyObject * obj0 = 0 ;
10139 char *kwnames[] = {
10140 (char *) "msg", NULL
10141 };
10142
10143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10144 {
10145 arg1 = wxString_in_helper(obj0);
10146 if (arg1 == NULL) SWIG_fail;
10147 temp1 = true;
10148 }
10149 {
10150 PyThreadState* __tstate = wxPyBeginAllowThreads();
10151 wxPyLogError((wxString const &)*arg1);
10152
10153 wxPyEndAllowThreads(__tstate);
10154 if (PyErr_Occurred()) SWIG_fail;
10155 }
10156 Py_INCREF(Py_None); resultobj = Py_None;
10157 {
10158 if (temp1)
10159 delete arg1;
10160 }
10161 return resultobj;
10162 fail:
10163 {
10164 if (temp1)
10165 delete arg1;
10166 }
10167 return NULL;
10168 }
10169
10170
10171 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10172 PyObject *resultobj;
10173 wxString *arg1 = 0 ;
10174 bool temp1 = false ;
10175 PyObject * obj0 = 0 ;
10176 char *kwnames[] = {
10177 (char *) "msg", NULL
10178 };
10179
10180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10181 {
10182 arg1 = wxString_in_helper(obj0);
10183 if (arg1 == NULL) SWIG_fail;
10184 temp1 = true;
10185 }
10186 {
10187 PyThreadState* __tstate = wxPyBeginAllowThreads();
10188 wxPyLogWarning((wxString const &)*arg1);
10189
10190 wxPyEndAllowThreads(__tstate);
10191 if (PyErr_Occurred()) SWIG_fail;
10192 }
10193 Py_INCREF(Py_None); resultobj = Py_None;
10194 {
10195 if (temp1)
10196 delete arg1;
10197 }
10198 return resultobj;
10199 fail:
10200 {
10201 if (temp1)
10202 delete arg1;
10203 }
10204 return NULL;
10205 }
10206
10207
10208 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10209 PyObject *resultobj;
10210 wxString *arg1 = 0 ;
10211 bool temp1 = false ;
10212 PyObject * obj0 = 0 ;
10213 char *kwnames[] = {
10214 (char *) "msg", NULL
10215 };
10216
10217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10218 {
10219 arg1 = wxString_in_helper(obj0);
10220 if (arg1 == NULL) SWIG_fail;
10221 temp1 = true;
10222 }
10223 {
10224 PyThreadState* __tstate = wxPyBeginAllowThreads();
10225 wxPyLogMessage((wxString const &)*arg1);
10226
10227 wxPyEndAllowThreads(__tstate);
10228 if (PyErr_Occurred()) SWIG_fail;
10229 }
10230 Py_INCREF(Py_None); resultobj = Py_None;
10231 {
10232 if (temp1)
10233 delete arg1;
10234 }
10235 return resultobj;
10236 fail:
10237 {
10238 if (temp1)
10239 delete arg1;
10240 }
10241 return NULL;
10242 }
10243
10244
10245 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10246 PyObject *resultobj;
10247 wxString *arg1 = 0 ;
10248 bool temp1 = false ;
10249 PyObject * obj0 = 0 ;
10250 char *kwnames[] = {
10251 (char *) "msg", NULL
10252 };
10253
10254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10255 {
10256 arg1 = wxString_in_helper(obj0);
10257 if (arg1 == NULL) SWIG_fail;
10258 temp1 = true;
10259 }
10260 {
10261 PyThreadState* __tstate = wxPyBeginAllowThreads();
10262 wxPyLogInfo((wxString const &)*arg1);
10263
10264 wxPyEndAllowThreads(__tstate);
10265 if (PyErr_Occurred()) SWIG_fail;
10266 }
10267 Py_INCREF(Py_None); resultobj = Py_None;
10268 {
10269 if (temp1)
10270 delete arg1;
10271 }
10272 return resultobj;
10273 fail:
10274 {
10275 if (temp1)
10276 delete arg1;
10277 }
10278 return NULL;
10279 }
10280
10281
10282 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10283 PyObject *resultobj;
10284 wxString *arg1 = 0 ;
10285 bool temp1 = false ;
10286 PyObject * obj0 = 0 ;
10287 char *kwnames[] = {
10288 (char *) "msg", NULL
10289 };
10290
10291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10292 {
10293 arg1 = wxString_in_helper(obj0);
10294 if (arg1 == NULL) SWIG_fail;
10295 temp1 = true;
10296 }
10297 {
10298 PyThreadState* __tstate = wxPyBeginAllowThreads();
10299 wxPyLogDebug((wxString const &)*arg1);
10300
10301 wxPyEndAllowThreads(__tstate);
10302 if (PyErr_Occurred()) SWIG_fail;
10303 }
10304 Py_INCREF(Py_None); resultobj = Py_None;
10305 {
10306 if (temp1)
10307 delete arg1;
10308 }
10309 return resultobj;
10310 fail:
10311 {
10312 if (temp1)
10313 delete arg1;
10314 }
10315 return NULL;
10316 }
10317
10318
10319 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10320 PyObject *resultobj;
10321 wxString *arg1 = 0 ;
10322 bool temp1 = false ;
10323 PyObject * obj0 = 0 ;
10324 char *kwnames[] = {
10325 (char *) "msg", NULL
10326 };
10327
10328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10329 {
10330 arg1 = wxString_in_helper(obj0);
10331 if (arg1 == NULL) SWIG_fail;
10332 temp1 = true;
10333 }
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 wxPyLogVerbose((wxString const &)*arg1);
10337
10338 wxPyEndAllowThreads(__tstate);
10339 if (PyErr_Occurred()) SWIG_fail;
10340 }
10341 Py_INCREF(Py_None); resultobj = Py_None;
10342 {
10343 if (temp1)
10344 delete arg1;
10345 }
10346 return resultobj;
10347 fail:
10348 {
10349 if (temp1)
10350 delete arg1;
10351 }
10352 return NULL;
10353 }
10354
10355
10356 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10357 PyObject *resultobj;
10358 wxString *arg1 = 0 ;
10359 bool temp1 = false ;
10360 PyObject * obj0 = 0 ;
10361 char *kwnames[] = {
10362 (char *) "msg", NULL
10363 };
10364
10365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10366 {
10367 arg1 = wxString_in_helper(obj0);
10368 if (arg1 == NULL) SWIG_fail;
10369 temp1 = true;
10370 }
10371 {
10372 PyThreadState* __tstate = wxPyBeginAllowThreads();
10373 wxPyLogStatus((wxString const &)*arg1);
10374
10375 wxPyEndAllowThreads(__tstate);
10376 if (PyErr_Occurred()) SWIG_fail;
10377 }
10378 Py_INCREF(Py_None); resultobj = Py_None;
10379 {
10380 if (temp1)
10381 delete arg1;
10382 }
10383 return resultobj;
10384 fail:
10385 {
10386 if (temp1)
10387 delete arg1;
10388 }
10389 return NULL;
10390 }
10391
10392
10393 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10394 PyObject *resultobj;
10395 wxFrame *arg1 = (wxFrame *) 0 ;
10396 wxString *arg2 = 0 ;
10397 bool temp2 = false ;
10398 PyObject * obj0 = 0 ;
10399 PyObject * obj1 = 0 ;
10400 char *kwnames[] = {
10401 (char *) "pFrame",(char *) "msg", NULL
10402 };
10403
10404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10406 if (SWIG_arg_fail(1)) SWIG_fail;
10407 {
10408 arg2 = wxString_in_helper(obj1);
10409 if (arg2 == NULL) SWIG_fail;
10410 temp2 = true;
10411 }
10412 {
10413 PyThreadState* __tstate = wxPyBeginAllowThreads();
10414 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10415
10416 wxPyEndAllowThreads(__tstate);
10417 if (PyErr_Occurred()) SWIG_fail;
10418 }
10419 Py_INCREF(Py_None); resultobj = Py_None;
10420 {
10421 if (temp2)
10422 delete arg2;
10423 }
10424 return resultobj;
10425 fail:
10426 {
10427 if (temp2)
10428 delete arg2;
10429 }
10430 return NULL;
10431 }
10432
10433
10434 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10435 PyObject *resultobj;
10436 wxString *arg1 = 0 ;
10437 bool temp1 = false ;
10438 PyObject * obj0 = 0 ;
10439 char *kwnames[] = {
10440 (char *) "msg", NULL
10441 };
10442
10443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10444 {
10445 arg1 = wxString_in_helper(obj0);
10446 if (arg1 == NULL) SWIG_fail;
10447 temp1 = true;
10448 }
10449 {
10450 PyThreadState* __tstate = wxPyBeginAllowThreads();
10451 wxPyLogSysError((wxString const &)*arg1);
10452
10453 wxPyEndAllowThreads(__tstate);
10454 if (PyErr_Occurred()) SWIG_fail;
10455 }
10456 Py_INCREF(Py_None); resultobj = Py_None;
10457 {
10458 if (temp1)
10459 delete arg1;
10460 }
10461 return resultobj;
10462 fail:
10463 {
10464 if (temp1)
10465 delete arg1;
10466 }
10467 return NULL;
10468 }
10469
10470
10471 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10472 PyObject *resultobj;
10473 unsigned long arg1 ;
10474 wxString *arg2 = 0 ;
10475 bool temp2 = false ;
10476 PyObject * obj0 = 0 ;
10477 PyObject * obj1 = 0 ;
10478 char *kwnames[] = {
10479 (char *) "level",(char *) "msg", NULL
10480 };
10481
10482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10483 {
10484 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10485 if (SWIG_arg_fail(1)) SWIG_fail;
10486 }
10487 {
10488 arg2 = wxString_in_helper(obj1);
10489 if (arg2 == NULL) SWIG_fail;
10490 temp2 = true;
10491 }
10492 {
10493 PyThreadState* __tstate = wxPyBeginAllowThreads();
10494 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10495
10496 wxPyEndAllowThreads(__tstate);
10497 if (PyErr_Occurred()) SWIG_fail;
10498 }
10499 Py_INCREF(Py_None); resultobj = Py_None;
10500 {
10501 if (temp2)
10502 delete arg2;
10503 }
10504 return resultobj;
10505 fail:
10506 {
10507 if (temp2)
10508 delete arg2;
10509 }
10510 return NULL;
10511 }
10512
10513
10514 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10515 PyObject *resultobj;
10516 unsigned long arg1 ;
10517 wxString *arg2 = 0 ;
10518 bool temp2 = false ;
10519 PyObject * obj0 = 0 ;
10520 PyObject * obj1 = 0 ;
10521
10522 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10523 {
10524 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10525 if (SWIG_arg_fail(1)) SWIG_fail;
10526 }
10527 {
10528 arg2 = wxString_in_helper(obj1);
10529 if (arg2 == NULL) SWIG_fail;
10530 temp2 = true;
10531 }
10532 {
10533 PyThreadState* __tstate = wxPyBeginAllowThreads();
10534 wxPyLogTrace(arg1,(wxString const &)*arg2);
10535
10536 wxPyEndAllowThreads(__tstate);
10537 if (PyErr_Occurred()) SWIG_fail;
10538 }
10539 Py_INCREF(Py_None); resultobj = Py_None;
10540 {
10541 if (temp2)
10542 delete arg2;
10543 }
10544 return resultobj;
10545 fail:
10546 {
10547 if (temp2)
10548 delete arg2;
10549 }
10550 return NULL;
10551 }
10552
10553
10554 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10555 PyObject *resultobj;
10556 wxString *arg1 = 0 ;
10557 wxString *arg2 = 0 ;
10558 bool temp1 = false ;
10559 bool temp2 = false ;
10560 PyObject * obj0 = 0 ;
10561 PyObject * obj1 = 0 ;
10562
10563 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10564 {
10565 arg1 = wxString_in_helper(obj0);
10566 if (arg1 == NULL) SWIG_fail;
10567 temp1 = true;
10568 }
10569 {
10570 arg2 = wxString_in_helper(obj1);
10571 if (arg2 == NULL) SWIG_fail;
10572 temp2 = true;
10573 }
10574 {
10575 PyThreadState* __tstate = wxPyBeginAllowThreads();
10576 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10577
10578 wxPyEndAllowThreads(__tstate);
10579 if (PyErr_Occurred()) SWIG_fail;
10580 }
10581 Py_INCREF(Py_None); resultobj = Py_None;
10582 {
10583 if (temp1)
10584 delete arg1;
10585 }
10586 {
10587 if (temp2)
10588 delete arg2;
10589 }
10590 return resultobj;
10591 fail:
10592 {
10593 if (temp1)
10594 delete arg1;
10595 }
10596 {
10597 if (temp2)
10598 delete arg2;
10599 }
10600 return NULL;
10601 }
10602
10603
10604 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10605 int argc;
10606 PyObject *argv[3];
10607 int ii;
10608
10609 argc = PyObject_Length(args);
10610 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10611 argv[ii] = PyTuple_GetItem(args,ii);
10612 }
10613 if (argc == 2) {
10614 int _v;
10615 {
10616 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10617 }
10618 if (_v) {
10619 {
10620 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10621 }
10622 if (_v) {
10623 return _wrap_LogTrace__SWIG_1(self,args);
10624 }
10625 }
10626 }
10627 if (argc == 2) {
10628 int _v;
10629 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10630 if (_v) {
10631 {
10632 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10633 }
10634 if (_v) {
10635 return _wrap_LogTrace__SWIG_0(self,args);
10636 }
10637 }
10638 }
10639
10640 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10641 return NULL;
10642 }
10643
10644
10645 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10646 PyObject *resultobj;
10647 wxString *arg1 = 0 ;
10648 wxString *arg2 = 0 ;
10649 bool temp1 = false ;
10650 bool temp2 = false ;
10651 PyObject * obj0 = 0 ;
10652 PyObject * obj1 = 0 ;
10653 char *kwnames[] = {
10654 (char *) "title",(char *) "text", NULL
10655 };
10656
10657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10658 {
10659 arg1 = wxString_in_helper(obj0);
10660 if (arg1 == NULL) SWIG_fail;
10661 temp1 = true;
10662 }
10663 {
10664 arg2 = wxString_in_helper(obj1);
10665 if (arg2 == NULL) SWIG_fail;
10666 temp2 = true;
10667 }
10668 {
10669 PyThreadState* __tstate = wxPyBeginAllowThreads();
10670 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10671
10672 wxPyEndAllowThreads(__tstate);
10673 if (PyErr_Occurred()) SWIG_fail;
10674 }
10675 Py_INCREF(Py_None); resultobj = Py_None;
10676 {
10677 if (temp1)
10678 delete arg1;
10679 }
10680 {
10681 if (temp2)
10682 delete arg2;
10683 }
10684 return resultobj;
10685 fail:
10686 {
10687 if (temp1)
10688 delete arg1;
10689 }
10690 {
10691 if (temp2)
10692 delete arg2;
10693 }
10694 return NULL;
10695 }
10696
10697
10698 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10699 PyObject *resultobj;
10700 wxLogNull *result;
10701 char *kwnames[] = {
10702 NULL
10703 };
10704
10705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10706 {
10707 PyThreadState* __tstate = wxPyBeginAllowThreads();
10708 result = (wxLogNull *)new wxLogNull();
10709
10710 wxPyEndAllowThreads(__tstate);
10711 if (PyErr_Occurred()) SWIG_fail;
10712 }
10713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10714 return resultobj;
10715 fail:
10716 return NULL;
10717 }
10718
10719
10720 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10721 PyObject *resultobj;
10722 wxLogNull *arg1 = (wxLogNull *) 0 ;
10723 PyObject * obj0 = 0 ;
10724 char *kwnames[] = {
10725 (char *) "self", NULL
10726 };
10727
10728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10730 if (SWIG_arg_fail(1)) SWIG_fail;
10731 {
10732 PyThreadState* __tstate = wxPyBeginAllowThreads();
10733 delete arg1;
10734
10735 wxPyEndAllowThreads(__tstate);
10736 if (PyErr_Occurred()) SWIG_fail;
10737 }
10738 Py_INCREF(Py_None); resultobj = Py_None;
10739 return resultobj;
10740 fail:
10741 return NULL;
10742 }
10743
10744
10745 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10746 PyObject *obj;
10747 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10748 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10749 Py_INCREF(obj);
10750 return Py_BuildValue((char *)"");
10751 }
10752 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10753 PyObject *resultobj;
10754 wxPyLog *result;
10755 char *kwnames[] = {
10756 NULL
10757 };
10758
10759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10760 {
10761 PyThreadState* __tstate = wxPyBeginAllowThreads();
10762 result = (wxPyLog *)new wxPyLog();
10763
10764 wxPyEndAllowThreads(__tstate);
10765 if (PyErr_Occurred()) SWIG_fail;
10766 }
10767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10768 return resultobj;
10769 fail:
10770 return NULL;
10771 }
10772
10773
10774 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10775 PyObject *resultobj;
10776 wxPyLog *arg1 = (wxPyLog *) 0 ;
10777 PyObject *arg2 = (PyObject *) 0 ;
10778 PyObject *arg3 = (PyObject *) 0 ;
10779 PyObject * obj0 = 0 ;
10780 PyObject * obj1 = 0 ;
10781 PyObject * obj2 = 0 ;
10782 char *kwnames[] = {
10783 (char *) "self",(char *) "self",(char *) "_class", NULL
10784 };
10785
10786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10788 if (SWIG_arg_fail(1)) SWIG_fail;
10789 arg2 = obj1;
10790 arg3 = obj2;
10791 {
10792 PyThreadState* __tstate = wxPyBeginAllowThreads();
10793 (arg1)->_setCallbackInfo(arg2,arg3);
10794
10795 wxPyEndAllowThreads(__tstate);
10796 if (PyErr_Occurred()) SWIG_fail;
10797 }
10798 Py_INCREF(Py_None); resultobj = Py_None;
10799 return resultobj;
10800 fail:
10801 return NULL;
10802 }
10803
10804
10805 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10806 PyObject *obj;
10807 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10808 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10809 Py_INCREF(obj);
10810 return Py_BuildValue((char *)"");
10811 }
10812 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10813 PyObject *resultobj;
10814 int arg1 ;
10815 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10816 int arg3 = (int) wxKILL_NOCHILDREN ;
10817 wxKillError result;
10818 PyObject * obj0 = 0 ;
10819 PyObject * obj1 = 0 ;
10820 PyObject * obj2 = 0 ;
10821 char *kwnames[] = {
10822 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10823 };
10824
10825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10826 {
10827 arg1 = (int)(SWIG_As_int(obj0));
10828 if (SWIG_arg_fail(1)) SWIG_fail;
10829 }
10830 if (obj1) {
10831 {
10832 arg2 = (wxSignal)(SWIG_As_int(obj1));
10833 if (SWIG_arg_fail(2)) SWIG_fail;
10834 }
10835 }
10836 if (obj2) {
10837 {
10838 arg3 = (int)(SWIG_As_int(obj2));
10839 if (SWIG_arg_fail(3)) SWIG_fail;
10840 }
10841 }
10842 {
10843 PyThreadState* __tstate = wxPyBeginAllowThreads();
10844 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10845
10846 wxPyEndAllowThreads(__tstate);
10847 if (PyErr_Occurred()) SWIG_fail;
10848 }
10849 resultobj = SWIG_From_int((result));
10850 return resultobj;
10851 fail:
10852 return NULL;
10853 }
10854
10855
10856 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10857 PyObject *resultobj;
10858 int arg1 ;
10859 bool result;
10860 PyObject * obj0 = 0 ;
10861 char *kwnames[] = {
10862 (char *) "pid", NULL
10863 };
10864
10865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10866 {
10867 arg1 = (int)(SWIG_As_int(obj0));
10868 if (SWIG_arg_fail(1)) SWIG_fail;
10869 }
10870 {
10871 PyThreadState* __tstate = wxPyBeginAllowThreads();
10872 result = (bool)wxPyProcess::Exists(arg1);
10873
10874 wxPyEndAllowThreads(__tstate);
10875 if (PyErr_Occurred()) SWIG_fail;
10876 }
10877 {
10878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10879 }
10880 return resultobj;
10881 fail:
10882 return NULL;
10883 }
10884
10885
10886 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10887 PyObject *resultobj;
10888 wxString *arg1 = 0 ;
10889 int arg2 = (int) wxEXEC_ASYNC ;
10890 wxPyProcess *result;
10891 bool temp1 = false ;
10892 PyObject * obj0 = 0 ;
10893 PyObject * obj1 = 0 ;
10894 char *kwnames[] = {
10895 (char *) "cmd",(char *) "flags", NULL
10896 };
10897
10898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10899 {
10900 arg1 = wxString_in_helper(obj0);
10901 if (arg1 == NULL) SWIG_fail;
10902 temp1 = true;
10903 }
10904 if (obj1) {
10905 {
10906 arg2 = (int)(SWIG_As_int(obj1));
10907 if (SWIG_arg_fail(2)) SWIG_fail;
10908 }
10909 }
10910 {
10911 PyThreadState* __tstate = wxPyBeginAllowThreads();
10912 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10913
10914 wxPyEndAllowThreads(__tstate);
10915 if (PyErr_Occurred()) SWIG_fail;
10916 }
10917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10918 {
10919 if (temp1)
10920 delete arg1;
10921 }
10922 return resultobj;
10923 fail:
10924 {
10925 if (temp1)
10926 delete arg1;
10927 }
10928 return NULL;
10929 }
10930
10931
10932 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10933 PyObject *resultobj;
10934 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10935 int arg2 = (int) -1 ;
10936 wxPyProcess *result;
10937 PyObject * obj0 = 0 ;
10938 PyObject * obj1 = 0 ;
10939 char *kwnames[] = {
10940 (char *) "parent",(char *) "id", NULL
10941 };
10942
10943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10944 if (obj0) {
10945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10946 if (SWIG_arg_fail(1)) SWIG_fail;
10947 }
10948 if (obj1) {
10949 {
10950 arg2 = (int)(SWIG_As_int(obj1));
10951 if (SWIG_arg_fail(2)) SWIG_fail;
10952 }
10953 }
10954 {
10955 PyThreadState* __tstate = wxPyBeginAllowThreads();
10956 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10957
10958 wxPyEndAllowThreads(__tstate);
10959 if (PyErr_Occurred()) SWIG_fail;
10960 }
10961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10962 return resultobj;
10963 fail:
10964 return NULL;
10965 }
10966
10967
10968 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10969 PyObject *resultobj;
10970 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10971 PyObject *arg2 = (PyObject *) 0 ;
10972 PyObject *arg3 = (PyObject *) 0 ;
10973 PyObject * obj0 = 0 ;
10974 PyObject * obj1 = 0 ;
10975 PyObject * obj2 = 0 ;
10976 char *kwnames[] = {
10977 (char *) "self",(char *) "self",(char *) "_class", NULL
10978 };
10979
10980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10982 if (SWIG_arg_fail(1)) SWIG_fail;
10983 arg2 = obj1;
10984 arg3 = obj2;
10985 {
10986 PyThreadState* __tstate = wxPyBeginAllowThreads();
10987 (arg1)->_setCallbackInfo(arg2,arg3);
10988
10989 wxPyEndAllowThreads(__tstate);
10990 if (PyErr_Occurred()) SWIG_fail;
10991 }
10992 Py_INCREF(Py_None); resultobj = Py_None;
10993 return resultobj;
10994 fail:
10995 return NULL;
10996 }
10997
10998
10999 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
11000 PyObject *resultobj;
11001 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11002 int arg2 ;
11003 int arg3 ;
11004 PyObject * obj0 = 0 ;
11005 PyObject * obj1 = 0 ;
11006 PyObject * obj2 = 0 ;
11007 char *kwnames[] = {
11008 (char *) "self",(char *) "pid",(char *) "status", NULL
11009 };
11010
11011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
11012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11013 if (SWIG_arg_fail(1)) SWIG_fail;
11014 {
11015 arg2 = (int)(SWIG_As_int(obj1));
11016 if (SWIG_arg_fail(2)) SWIG_fail;
11017 }
11018 {
11019 arg3 = (int)(SWIG_As_int(obj2));
11020 if (SWIG_arg_fail(3)) SWIG_fail;
11021 }
11022 {
11023 PyThreadState* __tstate = wxPyBeginAllowThreads();
11024 (arg1)->base_OnTerminate(arg2,arg3);
11025
11026 wxPyEndAllowThreads(__tstate);
11027 if (PyErr_Occurred()) SWIG_fail;
11028 }
11029 Py_INCREF(Py_None); resultobj = Py_None;
11030 return resultobj;
11031 fail:
11032 return NULL;
11033 }
11034
11035
11036 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11037 PyObject *resultobj;
11038 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11039 PyObject * obj0 = 0 ;
11040 char *kwnames[] = {
11041 (char *) "self", NULL
11042 };
11043
11044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11046 if (SWIG_arg_fail(1)) SWIG_fail;
11047 {
11048 PyThreadState* __tstate = wxPyBeginAllowThreads();
11049 (arg1)->Redirect();
11050
11051 wxPyEndAllowThreads(__tstate);
11052 if (PyErr_Occurred()) SWIG_fail;
11053 }
11054 Py_INCREF(Py_None); resultobj = Py_None;
11055 return resultobj;
11056 fail:
11057 return NULL;
11058 }
11059
11060
11061 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11062 PyObject *resultobj;
11063 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11064 bool result;
11065 PyObject * obj0 = 0 ;
11066 char *kwnames[] = {
11067 (char *) "self", NULL
11068 };
11069
11070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11072 if (SWIG_arg_fail(1)) SWIG_fail;
11073 {
11074 PyThreadState* __tstate = wxPyBeginAllowThreads();
11075 result = (bool)(arg1)->IsRedirected();
11076
11077 wxPyEndAllowThreads(__tstate);
11078 if (PyErr_Occurred()) SWIG_fail;
11079 }
11080 {
11081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11082 }
11083 return resultobj;
11084 fail:
11085 return NULL;
11086 }
11087
11088
11089 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11090 PyObject *resultobj;
11091 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11092 PyObject * obj0 = 0 ;
11093 char *kwnames[] = {
11094 (char *) "self", NULL
11095 };
11096
11097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11099 if (SWIG_arg_fail(1)) SWIG_fail;
11100 {
11101 PyThreadState* __tstate = wxPyBeginAllowThreads();
11102 (arg1)->Detach();
11103
11104 wxPyEndAllowThreads(__tstate);
11105 if (PyErr_Occurred()) SWIG_fail;
11106 }
11107 Py_INCREF(Py_None); resultobj = Py_None;
11108 return resultobj;
11109 fail:
11110 return NULL;
11111 }
11112
11113
11114 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11115 PyObject *resultobj;
11116 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11117 wxInputStream *result;
11118 PyObject * obj0 = 0 ;
11119 char *kwnames[] = {
11120 (char *) "self", NULL
11121 };
11122
11123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11125 if (SWIG_arg_fail(1)) SWIG_fail;
11126 {
11127 PyThreadState* __tstate = wxPyBeginAllowThreads();
11128 result = (wxInputStream *)(arg1)->GetInputStream();
11129
11130 wxPyEndAllowThreads(__tstate);
11131 if (PyErr_Occurred()) SWIG_fail;
11132 }
11133 {
11134 wxPyInputStream * _ptr = NULL;
11135
11136 if (result) {
11137 _ptr = new wxPyInputStream(result);
11138 }
11139 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11140 }
11141 return resultobj;
11142 fail:
11143 return NULL;
11144 }
11145
11146
11147 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11148 PyObject *resultobj;
11149 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11150 wxInputStream *result;
11151 PyObject * obj0 = 0 ;
11152 char *kwnames[] = {
11153 (char *) "self", NULL
11154 };
11155
11156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11158 if (SWIG_arg_fail(1)) SWIG_fail;
11159 {
11160 PyThreadState* __tstate = wxPyBeginAllowThreads();
11161 result = (wxInputStream *)(arg1)->GetErrorStream();
11162
11163 wxPyEndAllowThreads(__tstate);
11164 if (PyErr_Occurred()) SWIG_fail;
11165 }
11166 {
11167 wxPyInputStream * _ptr = NULL;
11168
11169 if (result) {
11170 _ptr = new wxPyInputStream(result);
11171 }
11172 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11173 }
11174 return resultobj;
11175 fail:
11176 return NULL;
11177 }
11178
11179
11180 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11181 PyObject *resultobj;
11182 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11183 wxOutputStream *result;
11184 PyObject * obj0 = 0 ;
11185 char *kwnames[] = {
11186 (char *) "self", NULL
11187 };
11188
11189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11191 if (SWIG_arg_fail(1)) SWIG_fail;
11192 {
11193 PyThreadState* __tstate = wxPyBeginAllowThreads();
11194 result = (wxOutputStream *)(arg1)->GetOutputStream();
11195
11196 wxPyEndAllowThreads(__tstate);
11197 if (PyErr_Occurred()) SWIG_fail;
11198 }
11199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11200 return resultobj;
11201 fail:
11202 return NULL;
11203 }
11204
11205
11206 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11207 PyObject *resultobj;
11208 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11209 PyObject * obj0 = 0 ;
11210 char *kwnames[] = {
11211 (char *) "self", NULL
11212 };
11213
11214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11216 if (SWIG_arg_fail(1)) SWIG_fail;
11217 {
11218 PyThreadState* __tstate = wxPyBeginAllowThreads();
11219 (arg1)->CloseOutput();
11220
11221 wxPyEndAllowThreads(__tstate);
11222 if (PyErr_Occurred()) SWIG_fail;
11223 }
11224 Py_INCREF(Py_None); resultobj = Py_None;
11225 return resultobj;
11226 fail:
11227 return NULL;
11228 }
11229
11230
11231 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11232 PyObject *resultobj;
11233 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11234 bool result;
11235 PyObject * obj0 = 0 ;
11236 char *kwnames[] = {
11237 (char *) "self", NULL
11238 };
11239
11240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11242 if (SWIG_arg_fail(1)) SWIG_fail;
11243 {
11244 PyThreadState* __tstate = wxPyBeginAllowThreads();
11245 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11246
11247 wxPyEndAllowThreads(__tstate);
11248 if (PyErr_Occurred()) SWIG_fail;
11249 }
11250 {
11251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11252 }
11253 return resultobj;
11254 fail:
11255 return NULL;
11256 }
11257
11258
11259 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11260 PyObject *resultobj;
11261 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11262 bool result;
11263 PyObject * obj0 = 0 ;
11264 char *kwnames[] = {
11265 (char *) "self", NULL
11266 };
11267
11268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11270 if (SWIG_arg_fail(1)) SWIG_fail;
11271 {
11272 PyThreadState* __tstate = wxPyBeginAllowThreads();
11273 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11274
11275 wxPyEndAllowThreads(__tstate);
11276 if (PyErr_Occurred()) SWIG_fail;
11277 }
11278 {
11279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11280 }
11281 return resultobj;
11282 fail:
11283 return NULL;
11284 }
11285
11286
11287 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11288 PyObject *resultobj;
11289 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11290 bool result;
11291 PyObject * obj0 = 0 ;
11292 char *kwnames[] = {
11293 (char *) "self", NULL
11294 };
11295
11296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11298 if (SWIG_arg_fail(1)) SWIG_fail;
11299 {
11300 PyThreadState* __tstate = wxPyBeginAllowThreads();
11301 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11302
11303 wxPyEndAllowThreads(__tstate);
11304 if (PyErr_Occurred()) SWIG_fail;
11305 }
11306 {
11307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11308 }
11309 return resultobj;
11310 fail:
11311 return NULL;
11312 }
11313
11314
11315 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11316 PyObject *obj;
11317 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11318 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11319 Py_INCREF(obj);
11320 return Py_BuildValue((char *)"");
11321 }
11322 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11323 PyObject *resultobj;
11324 int arg1 = (int) 0 ;
11325 int arg2 = (int) 0 ;
11326 int arg3 = (int) 0 ;
11327 wxProcessEvent *result;
11328 PyObject * obj0 = 0 ;
11329 PyObject * obj1 = 0 ;
11330 PyObject * obj2 = 0 ;
11331 char *kwnames[] = {
11332 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11333 };
11334
11335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11336 if (obj0) {
11337 {
11338 arg1 = (int)(SWIG_As_int(obj0));
11339 if (SWIG_arg_fail(1)) SWIG_fail;
11340 }
11341 }
11342 if (obj1) {
11343 {
11344 arg2 = (int)(SWIG_As_int(obj1));
11345 if (SWIG_arg_fail(2)) SWIG_fail;
11346 }
11347 }
11348 if (obj2) {
11349 {
11350 arg3 = (int)(SWIG_As_int(obj2));
11351 if (SWIG_arg_fail(3)) SWIG_fail;
11352 }
11353 }
11354 {
11355 PyThreadState* __tstate = wxPyBeginAllowThreads();
11356 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11357
11358 wxPyEndAllowThreads(__tstate);
11359 if (PyErr_Occurred()) SWIG_fail;
11360 }
11361 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11362 return resultobj;
11363 fail:
11364 return NULL;
11365 }
11366
11367
11368 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11369 PyObject *resultobj;
11370 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11371 int result;
11372 PyObject * obj0 = 0 ;
11373 char *kwnames[] = {
11374 (char *) "self", NULL
11375 };
11376
11377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11379 if (SWIG_arg_fail(1)) SWIG_fail;
11380 {
11381 PyThreadState* __tstate = wxPyBeginAllowThreads();
11382 result = (int)(arg1)->GetPid();
11383
11384 wxPyEndAllowThreads(__tstate);
11385 if (PyErr_Occurred()) SWIG_fail;
11386 }
11387 {
11388 resultobj = SWIG_From_int((int)(result));
11389 }
11390 return resultobj;
11391 fail:
11392 return NULL;
11393 }
11394
11395
11396 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11397 PyObject *resultobj;
11398 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11399 int result;
11400 PyObject * obj0 = 0 ;
11401 char *kwnames[] = {
11402 (char *) "self", NULL
11403 };
11404
11405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11407 if (SWIG_arg_fail(1)) SWIG_fail;
11408 {
11409 PyThreadState* __tstate = wxPyBeginAllowThreads();
11410 result = (int)(arg1)->GetExitCode();
11411
11412 wxPyEndAllowThreads(__tstate);
11413 if (PyErr_Occurred()) SWIG_fail;
11414 }
11415 {
11416 resultobj = SWIG_From_int((int)(result));
11417 }
11418 return resultobj;
11419 fail:
11420 return NULL;
11421 }
11422
11423
11424 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11425 PyObject *resultobj;
11426 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11427 int arg2 ;
11428 PyObject * obj0 = 0 ;
11429 PyObject * obj1 = 0 ;
11430 char *kwnames[] = {
11431 (char *) "self",(char *) "m_pid", NULL
11432 };
11433
11434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11436 if (SWIG_arg_fail(1)) SWIG_fail;
11437 {
11438 arg2 = (int)(SWIG_As_int(obj1));
11439 if (SWIG_arg_fail(2)) SWIG_fail;
11440 }
11441 if (arg1) (arg1)->m_pid = arg2;
11442
11443 Py_INCREF(Py_None); resultobj = Py_None;
11444 return resultobj;
11445 fail:
11446 return NULL;
11447 }
11448
11449
11450 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11451 PyObject *resultobj;
11452 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11453 int result;
11454 PyObject * obj0 = 0 ;
11455 char *kwnames[] = {
11456 (char *) "self", NULL
11457 };
11458
11459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11461 if (SWIG_arg_fail(1)) SWIG_fail;
11462 result = (int) ((arg1)->m_pid);
11463
11464 {
11465 resultobj = SWIG_From_int((int)(result));
11466 }
11467 return resultobj;
11468 fail:
11469 return NULL;
11470 }
11471
11472
11473 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11474 PyObject *resultobj;
11475 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11476 int arg2 ;
11477 PyObject * obj0 = 0 ;
11478 PyObject * obj1 = 0 ;
11479 char *kwnames[] = {
11480 (char *) "self",(char *) "m_exitcode", NULL
11481 };
11482
11483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11485 if (SWIG_arg_fail(1)) SWIG_fail;
11486 {
11487 arg2 = (int)(SWIG_As_int(obj1));
11488 if (SWIG_arg_fail(2)) SWIG_fail;
11489 }
11490 if (arg1) (arg1)->m_exitcode = arg2;
11491
11492 Py_INCREF(Py_None); resultobj = Py_None;
11493 return resultobj;
11494 fail:
11495 return NULL;
11496 }
11497
11498
11499 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11500 PyObject *resultobj;
11501 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11502 int result;
11503 PyObject * obj0 = 0 ;
11504 char *kwnames[] = {
11505 (char *) "self", NULL
11506 };
11507
11508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11510 if (SWIG_arg_fail(1)) SWIG_fail;
11511 result = (int) ((arg1)->m_exitcode);
11512
11513 {
11514 resultobj = SWIG_From_int((int)(result));
11515 }
11516 return resultobj;
11517 fail:
11518 return NULL;
11519 }
11520
11521
11522 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11523 PyObject *obj;
11524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11525 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11526 Py_INCREF(obj);
11527 return Py_BuildValue((char *)"");
11528 }
11529 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11530 PyObject *resultobj;
11531 wxString *arg1 = 0 ;
11532 int arg2 = (int) wxEXEC_ASYNC ;
11533 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11534 long result;
11535 bool temp1 = false ;
11536 PyObject * obj0 = 0 ;
11537 PyObject * obj1 = 0 ;
11538 PyObject * obj2 = 0 ;
11539 char *kwnames[] = {
11540 (char *) "command",(char *) "flags",(char *) "process", NULL
11541 };
11542
11543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11544 {
11545 arg1 = wxString_in_helper(obj0);
11546 if (arg1 == NULL) SWIG_fail;
11547 temp1 = true;
11548 }
11549 if (obj1) {
11550 {
11551 arg2 = (int)(SWIG_As_int(obj1));
11552 if (SWIG_arg_fail(2)) SWIG_fail;
11553 }
11554 }
11555 if (obj2) {
11556 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11557 if (SWIG_arg_fail(3)) SWIG_fail;
11558 }
11559 {
11560 if (!wxPyCheckForApp()) SWIG_fail;
11561 PyThreadState* __tstate = wxPyBeginAllowThreads();
11562 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11563
11564 wxPyEndAllowThreads(__tstate);
11565 if (PyErr_Occurred()) SWIG_fail;
11566 }
11567 {
11568 resultobj = SWIG_From_long((long)(result));
11569 }
11570 {
11571 if (temp1)
11572 delete arg1;
11573 }
11574 return resultobj;
11575 fail:
11576 {
11577 if (temp1)
11578 delete arg1;
11579 }
11580 return NULL;
11581 }
11582
11583
11584 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11585 PyObject *resultobj;
11586 long arg1 ;
11587 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11588 wxKillError *arg3 = (wxKillError *) 0 ;
11589 int arg4 = (int) wxKILL_NOCHILDREN ;
11590 int result;
11591 wxKillError temp3 ;
11592 PyObject * obj0 = 0 ;
11593 PyObject * obj1 = 0 ;
11594 PyObject * obj2 = 0 ;
11595 char *kwnames[] = {
11596 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11597 };
11598
11599 {
11600 arg3 = &temp3;
11601 }
11602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11603 {
11604 arg1 = (long)(SWIG_As_long(obj0));
11605 if (SWIG_arg_fail(1)) SWIG_fail;
11606 }
11607 if (obj1) {
11608 {
11609 arg2 = (wxSignal)(SWIG_As_int(obj1));
11610 if (SWIG_arg_fail(2)) SWIG_fail;
11611 }
11612 }
11613 if (obj2) {
11614 {
11615 arg4 = (int)(SWIG_As_int(obj2));
11616 if (SWIG_arg_fail(4)) SWIG_fail;
11617 }
11618 }
11619 {
11620 PyThreadState* __tstate = wxPyBeginAllowThreads();
11621 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11622
11623 wxPyEndAllowThreads(__tstate);
11624 if (PyErr_Occurred()) SWIG_fail;
11625 }
11626 {
11627 resultobj = SWIG_From_int((int)(result));
11628 }
11629 {
11630 PyObject* o;
11631 o = PyInt_FromLong((long) (*arg3));
11632 resultobj = t_output_helper(resultobj, o);
11633 }
11634 return resultobj;
11635 fail:
11636 return NULL;
11637 }
11638
11639
11640 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11641 PyObject *resultobj;
11642 int arg1 = (int) wxJOYSTICK1 ;
11643 wxJoystick *result;
11644 PyObject * obj0 = 0 ;
11645 char *kwnames[] = {
11646 (char *) "joystick", NULL
11647 };
11648
11649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11650 if (obj0) {
11651 {
11652 arg1 = (int)(SWIG_As_int(obj0));
11653 if (SWIG_arg_fail(1)) SWIG_fail;
11654 }
11655 }
11656 {
11657 if (!wxPyCheckForApp()) SWIG_fail;
11658 PyThreadState* __tstate = wxPyBeginAllowThreads();
11659 result = (wxJoystick *)new wxJoystick(arg1);
11660
11661 wxPyEndAllowThreads(__tstate);
11662 if (PyErr_Occurred()) SWIG_fail;
11663 }
11664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11665 return resultobj;
11666 fail:
11667 return NULL;
11668 }
11669
11670
11671 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11672 PyObject *resultobj;
11673 wxJoystick *arg1 = (wxJoystick *) 0 ;
11674 PyObject * obj0 = 0 ;
11675 char *kwnames[] = {
11676 (char *) "self", NULL
11677 };
11678
11679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11681 if (SWIG_arg_fail(1)) SWIG_fail;
11682 {
11683 PyThreadState* __tstate = wxPyBeginAllowThreads();
11684 delete arg1;
11685
11686 wxPyEndAllowThreads(__tstate);
11687 if (PyErr_Occurred()) SWIG_fail;
11688 }
11689 Py_INCREF(Py_None); resultobj = Py_None;
11690 return resultobj;
11691 fail:
11692 return NULL;
11693 }
11694
11695
11696 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11697 PyObject *resultobj;
11698 wxJoystick *arg1 = (wxJoystick *) 0 ;
11699 wxPoint result;
11700 PyObject * obj0 = 0 ;
11701 char *kwnames[] = {
11702 (char *) "self", NULL
11703 };
11704
11705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11707 if (SWIG_arg_fail(1)) SWIG_fail;
11708 {
11709 PyThreadState* __tstate = wxPyBeginAllowThreads();
11710 result = (arg1)->GetPosition();
11711
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 {
11716 wxPoint * resultptr;
11717 resultptr = new wxPoint((wxPoint &)(result));
11718 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11719 }
11720 return resultobj;
11721 fail:
11722 return NULL;
11723 }
11724
11725
11726 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11727 PyObject *resultobj;
11728 wxJoystick *arg1 = (wxJoystick *) 0 ;
11729 int result;
11730 PyObject * obj0 = 0 ;
11731 char *kwnames[] = {
11732 (char *) "self", NULL
11733 };
11734
11735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11737 if (SWIG_arg_fail(1)) SWIG_fail;
11738 {
11739 PyThreadState* __tstate = wxPyBeginAllowThreads();
11740 result = (int)(arg1)->GetZPosition();
11741
11742 wxPyEndAllowThreads(__tstate);
11743 if (PyErr_Occurred()) SWIG_fail;
11744 }
11745 {
11746 resultobj = SWIG_From_int((int)(result));
11747 }
11748 return resultobj;
11749 fail:
11750 return NULL;
11751 }
11752
11753
11754 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11755 PyObject *resultobj;
11756 wxJoystick *arg1 = (wxJoystick *) 0 ;
11757 int result;
11758 PyObject * obj0 = 0 ;
11759 char *kwnames[] = {
11760 (char *) "self", NULL
11761 };
11762
11763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11765 if (SWIG_arg_fail(1)) SWIG_fail;
11766 {
11767 PyThreadState* __tstate = wxPyBeginAllowThreads();
11768 result = (int)(arg1)->GetButtonState();
11769
11770 wxPyEndAllowThreads(__tstate);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 {
11774 resultobj = SWIG_From_int((int)(result));
11775 }
11776 return resultobj;
11777 fail:
11778 return NULL;
11779 }
11780
11781
11782 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11783 PyObject *resultobj;
11784 wxJoystick *arg1 = (wxJoystick *) 0 ;
11785 int result;
11786 PyObject * obj0 = 0 ;
11787 char *kwnames[] = {
11788 (char *) "self", NULL
11789 };
11790
11791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11793 if (SWIG_arg_fail(1)) SWIG_fail;
11794 {
11795 PyThreadState* __tstate = wxPyBeginAllowThreads();
11796 result = (int)(arg1)->GetPOVPosition();
11797
11798 wxPyEndAllowThreads(__tstate);
11799 if (PyErr_Occurred()) SWIG_fail;
11800 }
11801 {
11802 resultobj = SWIG_From_int((int)(result));
11803 }
11804 return resultobj;
11805 fail:
11806 return NULL;
11807 }
11808
11809
11810 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11811 PyObject *resultobj;
11812 wxJoystick *arg1 = (wxJoystick *) 0 ;
11813 int result;
11814 PyObject * obj0 = 0 ;
11815 char *kwnames[] = {
11816 (char *) "self", NULL
11817 };
11818
11819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11821 if (SWIG_arg_fail(1)) SWIG_fail;
11822 {
11823 PyThreadState* __tstate = wxPyBeginAllowThreads();
11824 result = (int)(arg1)->GetPOVCTSPosition();
11825
11826 wxPyEndAllowThreads(__tstate);
11827 if (PyErr_Occurred()) SWIG_fail;
11828 }
11829 {
11830 resultobj = SWIG_From_int((int)(result));
11831 }
11832 return resultobj;
11833 fail:
11834 return NULL;
11835 }
11836
11837
11838 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11839 PyObject *resultobj;
11840 wxJoystick *arg1 = (wxJoystick *) 0 ;
11841 int result;
11842 PyObject * obj0 = 0 ;
11843 char *kwnames[] = {
11844 (char *) "self", NULL
11845 };
11846
11847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11849 if (SWIG_arg_fail(1)) SWIG_fail;
11850 {
11851 PyThreadState* __tstate = wxPyBeginAllowThreads();
11852 result = (int)(arg1)->GetRudderPosition();
11853
11854 wxPyEndAllowThreads(__tstate);
11855 if (PyErr_Occurred()) SWIG_fail;
11856 }
11857 {
11858 resultobj = SWIG_From_int((int)(result));
11859 }
11860 return resultobj;
11861 fail:
11862 return NULL;
11863 }
11864
11865
11866 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11867 PyObject *resultobj;
11868 wxJoystick *arg1 = (wxJoystick *) 0 ;
11869 int result;
11870 PyObject * obj0 = 0 ;
11871 char *kwnames[] = {
11872 (char *) "self", NULL
11873 };
11874
11875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11877 if (SWIG_arg_fail(1)) SWIG_fail;
11878 {
11879 PyThreadState* __tstate = wxPyBeginAllowThreads();
11880 result = (int)(arg1)->GetUPosition();
11881
11882 wxPyEndAllowThreads(__tstate);
11883 if (PyErr_Occurred()) SWIG_fail;
11884 }
11885 {
11886 resultobj = SWIG_From_int((int)(result));
11887 }
11888 return resultobj;
11889 fail:
11890 return NULL;
11891 }
11892
11893
11894 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11895 PyObject *resultobj;
11896 wxJoystick *arg1 = (wxJoystick *) 0 ;
11897 int result;
11898 PyObject * obj0 = 0 ;
11899 char *kwnames[] = {
11900 (char *) "self", NULL
11901 };
11902
11903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11905 if (SWIG_arg_fail(1)) SWIG_fail;
11906 {
11907 PyThreadState* __tstate = wxPyBeginAllowThreads();
11908 result = (int)(arg1)->GetVPosition();
11909
11910 wxPyEndAllowThreads(__tstate);
11911 if (PyErr_Occurred()) SWIG_fail;
11912 }
11913 {
11914 resultobj = SWIG_From_int((int)(result));
11915 }
11916 return resultobj;
11917 fail:
11918 return NULL;
11919 }
11920
11921
11922 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11923 PyObject *resultobj;
11924 wxJoystick *arg1 = (wxJoystick *) 0 ;
11925 int result;
11926 PyObject * obj0 = 0 ;
11927 char *kwnames[] = {
11928 (char *) "self", NULL
11929 };
11930
11931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11933 if (SWIG_arg_fail(1)) SWIG_fail;
11934 {
11935 PyThreadState* __tstate = wxPyBeginAllowThreads();
11936 result = (int)(arg1)->GetMovementThreshold();
11937
11938 wxPyEndAllowThreads(__tstate);
11939 if (PyErr_Occurred()) SWIG_fail;
11940 }
11941 {
11942 resultobj = SWIG_From_int((int)(result));
11943 }
11944 return resultobj;
11945 fail:
11946 return NULL;
11947 }
11948
11949
11950 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11951 PyObject *resultobj;
11952 wxJoystick *arg1 = (wxJoystick *) 0 ;
11953 int arg2 ;
11954 PyObject * obj0 = 0 ;
11955 PyObject * obj1 = 0 ;
11956 char *kwnames[] = {
11957 (char *) "self",(char *) "threshold", NULL
11958 };
11959
11960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11962 if (SWIG_arg_fail(1)) SWIG_fail;
11963 {
11964 arg2 = (int)(SWIG_As_int(obj1));
11965 if (SWIG_arg_fail(2)) SWIG_fail;
11966 }
11967 {
11968 PyThreadState* __tstate = wxPyBeginAllowThreads();
11969 (arg1)->SetMovementThreshold(arg2);
11970
11971 wxPyEndAllowThreads(__tstate);
11972 if (PyErr_Occurred()) SWIG_fail;
11973 }
11974 Py_INCREF(Py_None); resultobj = Py_None;
11975 return resultobj;
11976 fail:
11977 return NULL;
11978 }
11979
11980
11981 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11982 PyObject *resultobj;
11983 wxJoystick *arg1 = (wxJoystick *) 0 ;
11984 bool result;
11985 PyObject * obj0 = 0 ;
11986 char *kwnames[] = {
11987 (char *) "self", NULL
11988 };
11989
11990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11992 if (SWIG_arg_fail(1)) SWIG_fail;
11993 {
11994 PyThreadState* __tstate = wxPyBeginAllowThreads();
11995 result = (bool)(arg1)->IsOk();
11996
11997 wxPyEndAllowThreads(__tstate);
11998 if (PyErr_Occurred()) SWIG_fail;
11999 }
12000 {
12001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12002 }
12003 return resultobj;
12004 fail:
12005 return NULL;
12006 }
12007
12008
12009 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
12010 PyObject *resultobj;
12011 wxJoystick *arg1 = (wxJoystick *) 0 ;
12012 int result;
12013 PyObject * obj0 = 0 ;
12014 char *kwnames[] = {
12015 (char *) "self", NULL
12016 };
12017
12018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
12019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12020 if (SWIG_arg_fail(1)) SWIG_fail;
12021 {
12022 PyThreadState* __tstate = wxPyBeginAllowThreads();
12023 result = (int)(arg1)->GetNumberJoysticks();
12024
12025 wxPyEndAllowThreads(__tstate);
12026 if (PyErr_Occurred()) SWIG_fail;
12027 }
12028 {
12029 resultobj = SWIG_From_int((int)(result));
12030 }
12031 return resultobj;
12032 fail:
12033 return NULL;
12034 }
12035
12036
12037 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12038 PyObject *resultobj;
12039 wxJoystick *arg1 = (wxJoystick *) 0 ;
12040 int result;
12041 PyObject * obj0 = 0 ;
12042 char *kwnames[] = {
12043 (char *) "self", NULL
12044 };
12045
12046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12048 if (SWIG_arg_fail(1)) SWIG_fail;
12049 {
12050 PyThreadState* __tstate = wxPyBeginAllowThreads();
12051 result = (int)(arg1)->GetManufacturerId();
12052
12053 wxPyEndAllowThreads(__tstate);
12054 if (PyErr_Occurred()) SWIG_fail;
12055 }
12056 {
12057 resultobj = SWIG_From_int((int)(result));
12058 }
12059 return resultobj;
12060 fail:
12061 return NULL;
12062 }
12063
12064
12065 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12066 PyObject *resultobj;
12067 wxJoystick *arg1 = (wxJoystick *) 0 ;
12068 int result;
12069 PyObject * obj0 = 0 ;
12070 char *kwnames[] = {
12071 (char *) "self", NULL
12072 };
12073
12074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12076 if (SWIG_arg_fail(1)) SWIG_fail;
12077 {
12078 PyThreadState* __tstate = wxPyBeginAllowThreads();
12079 result = (int)(arg1)->GetProductId();
12080
12081 wxPyEndAllowThreads(__tstate);
12082 if (PyErr_Occurred()) SWIG_fail;
12083 }
12084 {
12085 resultobj = SWIG_From_int((int)(result));
12086 }
12087 return resultobj;
12088 fail:
12089 return NULL;
12090 }
12091
12092
12093 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12094 PyObject *resultobj;
12095 wxJoystick *arg1 = (wxJoystick *) 0 ;
12096 wxString result;
12097 PyObject * obj0 = 0 ;
12098 char *kwnames[] = {
12099 (char *) "self", NULL
12100 };
12101
12102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12104 if (SWIG_arg_fail(1)) SWIG_fail;
12105 {
12106 PyThreadState* __tstate = wxPyBeginAllowThreads();
12107 result = (arg1)->GetProductName();
12108
12109 wxPyEndAllowThreads(__tstate);
12110 if (PyErr_Occurred()) SWIG_fail;
12111 }
12112 {
12113 #if wxUSE_UNICODE
12114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12115 #else
12116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12117 #endif
12118 }
12119 return resultobj;
12120 fail:
12121 return NULL;
12122 }
12123
12124
12125 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12126 PyObject *resultobj;
12127 wxJoystick *arg1 = (wxJoystick *) 0 ;
12128 int result;
12129 PyObject * obj0 = 0 ;
12130 char *kwnames[] = {
12131 (char *) "self", NULL
12132 };
12133
12134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12136 if (SWIG_arg_fail(1)) SWIG_fail;
12137 {
12138 PyThreadState* __tstate = wxPyBeginAllowThreads();
12139 result = (int)(arg1)->GetXMin();
12140
12141 wxPyEndAllowThreads(__tstate);
12142 if (PyErr_Occurred()) SWIG_fail;
12143 }
12144 {
12145 resultobj = SWIG_From_int((int)(result));
12146 }
12147 return resultobj;
12148 fail:
12149 return NULL;
12150 }
12151
12152
12153 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12154 PyObject *resultobj;
12155 wxJoystick *arg1 = (wxJoystick *) 0 ;
12156 int result;
12157 PyObject * obj0 = 0 ;
12158 char *kwnames[] = {
12159 (char *) "self", NULL
12160 };
12161
12162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12164 if (SWIG_arg_fail(1)) SWIG_fail;
12165 {
12166 PyThreadState* __tstate = wxPyBeginAllowThreads();
12167 result = (int)(arg1)->GetYMin();
12168
12169 wxPyEndAllowThreads(__tstate);
12170 if (PyErr_Occurred()) SWIG_fail;
12171 }
12172 {
12173 resultobj = SWIG_From_int((int)(result));
12174 }
12175 return resultobj;
12176 fail:
12177 return NULL;
12178 }
12179
12180
12181 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12182 PyObject *resultobj;
12183 wxJoystick *arg1 = (wxJoystick *) 0 ;
12184 int result;
12185 PyObject * obj0 = 0 ;
12186 char *kwnames[] = {
12187 (char *) "self", NULL
12188 };
12189
12190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12192 if (SWIG_arg_fail(1)) SWIG_fail;
12193 {
12194 PyThreadState* __tstate = wxPyBeginAllowThreads();
12195 result = (int)(arg1)->GetZMin();
12196
12197 wxPyEndAllowThreads(__tstate);
12198 if (PyErr_Occurred()) SWIG_fail;
12199 }
12200 {
12201 resultobj = SWIG_From_int((int)(result));
12202 }
12203 return resultobj;
12204 fail:
12205 return NULL;
12206 }
12207
12208
12209 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12210 PyObject *resultobj;
12211 wxJoystick *arg1 = (wxJoystick *) 0 ;
12212 int result;
12213 PyObject * obj0 = 0 ;
12214 char *kwnames[] = {
12215 (char *) "self", NULL
12216 };
12217
12218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12220 if (SWIG_arg_fail(1)) SWIG_fail;
12221 {
12222 PyThreadState* __tstate = wxPyBeginAllowThreads();
12223 result = (int)(arg1)->GetXMax();
12224
12225 wxPyEndAllowThreads(__tstate);
12226 if (PyErr_Occurred()) SWIG_fail;
12227 }
12228 {
12229 resultobj = SWIG_From_int((int)(result));
12230 }
12231 return resultobj;
12232 fail:
12233 return NULL;
12234 }
12235
12236
12237 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12238 PyObject *resultobj;
12239 wxJoystick *arg1 = (wxJoystick *) 0 ;
12240 int result;
12241 PyObject * obj0 = 0 ;
12242 char *kwnames[] = {
12243 (char *) "self", NULL
12244 };
12245
12246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12248 if (SWIG_arg_fail(1)) SWIG_fail;
12249 {
12250 PyThreadState* __tstate = wxPyBeginAllowThreads();
12251 result = (int)(arg1)->GetYMax();
12252
12253 wxPyEndAllowThreads(__tstate);
12254 if (PyErr_Occurred()) SWIG_fail;
12255 }
12256 {
12257 resultobj = SWIG_From_int((int)(result));
12258 }
12259 return resultobj;
12260 fail:
12261 return NULL;
12262 }
12263
12264
12265 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12266 PyObject *resultobj;
12267 wxJoystick *arg1 = (wxJoystick *) 0 ;
12268 int result;
12269 PyObject * obj0 = 0 ;
12270 char *kwnames[] = {
12271 (char *) "self", NULL
12272 };
12273
12274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12276 if (SWIG_arg_fail(1)) SWIG_fail;
12277 {
12278 PyThreadState* __tstate = wxPyBeginAllowThreads();
12279 result = (int)(arg1)->GetZMax();
12280
12281 wxPyEndAllowThreads(__tstate);
12282 if (PyErr_Occurred()) SWIG_fail;
12283 }
12284 {
12285 resultobj = SWIG_From_int((int)(result));
12286 }
12287 return resultobj;
12288 fail:
12289 return NULL;
12290 }
12291
12292
12293 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12294 PyObject *resultobj;
12295 wxJoystick *arg1 = (wxJoystick *) 0 ;
12296 int result;
12297 PyObject * obj0 = 0 ;
12298 char *kwnames[] = {
12299 (char *) "self", NULL
12300 };
12301
12302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12304 if (SWIG_arg_fail(1)) SWIG_fail;
12305 {
12306 PyThreadState* __tstate = wxPyBeginAllowThreads();
12307 result = (int)(arg1)->GetNumberButtons();
12308
12309 wxPyEndAllowThreads(__tstate);
12310 if (PyErr_Occurred()) SWIG_fail;
12311 }
12312 {
12313 resultobj = SWIG_From_int((int)(result));
12314 }
12315 return resultobj;
12316 fail:
12317 return NULL;
12318 }
12319
12320
12321 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12322 PyObject *resultobj;
12323 wxJoystick *arg1 = (wxJoystick *) 0 ;
12324 int result;
12325 PyObject * obj0 = 0 ;
12326 char *kwnames[] = {
12327 (char *) "self", NULL
12328 };
12329
12330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12332 if (SWIG_arg_fail(1)) SWIG_fail;
12333 {
12334 PyThreadState* __tstate = wxPyBeginAllowThreads();
12335 result = (int)(arg1)->GetNumberAxes();
12336
12337 wxPyEndAllowThreads(__tstate);
12338 if (PyErr_Occurred()) SWIG_fail;
12339 }
12340 {
12341 resultobj = SWIG_From_int((int)(result));
12342 }
12343 return resultobj;
12344 fail:
12345 return NULL;
12346 }
12347
12348
12349 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12350 PyObject *resultobj;
12351 wxJoystick *arg1 = (wxJoystick *) 0 ;
12352 int result;
12353 PyObject * obj0 = 0 ;
12354 char *kwnames[] = {
12355 (char *) "self", NULL
12356 };
12357
12358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12360 if (SWIG_arg_fail(1)) SWIG_fail;
12361 {
12362 PyThreadState* __tstate = wxPyBeginAllowThreads();
12363 result = (int)(arg1)->GetMaxButtons();
12364
12365 wxPyEndAllowThreads(__tstate);
12366 if (PyErr_Occurred()) SWIG_fail;
12367 }
12368 {
12369 resultobj = SWIG_From_int((int)(result));
12370 }
12371 return resultobj;
12372 fail:
12373 return NULL;
12374 }
12375
12376
12377 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12378 PyObject *resultobj;
12379 wxJoystick *arg1 = (wxJoystick *) 0 ;
12380 int result;
12381 PyObject * obj0 = 0 ;
12382 char *kwnames[] = {
12383 (char *) "self", NULL
12384 };
12385
12386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12388 if (SWIG_arg_fail(1)) SWIG_fail;
12389 {
12390 PyThreadState* __tstate = wxPyBeginAllowThreads();
12391 result = (int)(arg1)->GetMaxAxes();
12392
12393 wxPyEndAllowThreads(__tstate);
12394 if (PyErr_Occurred()) SWIG_fail;
12395 }
12396 {
12397 resultobj = SWIG_From_int((int)(result));
12398 }
12399 return resultobj;
12400 fail:
12401 return NULL;
12402 }
12403
12404
12405 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12406 PyObject *resultobj;
12407 wxJoystick *arg1 = (wxJoystick *) 0 ;
12408 int result;
12409 PyObject * obj0 = 0 ;
12410 char *kwnames[] = {
12411 (char *) "self", NULL
12412 };
12413
12414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12416 if (SWIG_arg_fail(1)) SWIG_fail;
12417 {
12418 PyThreadState* __tstate = wxPyBeginAllowThreads();
12419 result = (int)(arg1)->GetPollingMin();
12420
12421 wxPyEndAllowThreads(__tstate);
12422 if (PyErr_Occurred()) SWIG_fail;
12423 }
12424 {
12425 resultobj = SWIG_From_int((int)(result));
12426 }
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12434 PyObject *resultobj;
12435 wxJoystick *arg1 = (wxJoystick *) 0 ;
12436 int result;
12437 PyObject * obj0 = 0 ;
12438 char *kwnames[] = {
12439 (char *) "self", NULL
12440 };
12441
12442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12444 if (SWIG_arg_fail(1)) SWIG_fail;
12445 {
12446 PyThreadState* __tstate = wxPyBeginAllowThreads();
12447 result = (int)(arg1)->GetPollingMax();
12448
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 {
12453 resultobj = SWIG_From_int((int)(result));
12454 }
12455 return resultobj;
12456 fail:
12457 return NULL;
12458 }
12459
12460
12461 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12462 PyObject *resultobj;
12463 wxJoystick *arg1 = (wxJoystick *) 0 ;
12464 int result;
12465 PyObject * obj0 = 0 ;
12466 char *kwnames[] = {
12467 (char *) "self", NULL
12468 };
12469
12470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12472 if (SWIG_arg_fail(1)) SWIG_fail;
12473 {
12474 PyThreadState* __tstate = wxPyBeginAllowThreads();
12475 result = (int)(arg1)->GetRudderMin();
12476
12477 wxPyEndAllowThreads(__tstate);
12478 if (PyErr_Occurred()) SWIG_fail;
12479 }
12480 {
12481 resultobj = SWIG_From_int((int)(result));
12482 }
12483 return resultobj;
12484 fail:
12485 return NULL;
12486 }
12487
12488
12489 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12490 PyObject *resultobj;
12491 wxJoystick *arg1 = (wxJoystick *) 0 ;
12492 int result;
12493 PyObject * obj0 = 0 ;
12494 char *kwnames[] = {
12495 (char *) "self", NULL
12496 };
12497
12498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12500 if (SWIG_arg_fail(1)) SWIG_fail;
12501 {
12502 PyThreadState* __tstate = wxPyBeginAllowThreads();
12503 result = (int)(arg1)->GetRudderMax();
12504
12505 wxPyEndAllowThreads(__tstate);
12506 if (PyErr_Occurred()) SWIG_fail;
12507 }
12508 {
12509 resultobj = SWIG_From_int((int)(result));
12510 }
12511 return resultobj;
12512 fail:
12513 return NULL;
12514 }
12515
12516
12517 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12518 PyObject *resultobj;
12519 wxJoystick *arg1 = (wxJoystick *) 0 ;
12520 int result;
12521 PyObject * obj0 = 0 ;
12522 char *kwnames[] = {
12523 (char *) "self", NULL
12524 };
12525
12526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12528 if (SWIG_arg_fail(1)) SWIG_fail;
12529 {
12530 PyThreadState* __tstate = wxPyBeginAllowThreads();
12531 result = (int)(arg1)->GetUMin();
12532
12533 wxPyEndAllowThreads(__tstate);
12534 if (PyErr_Occurred()) SWIG_fail;
12535 }
12536 {
12537 resultobj = SWIG_From_int((int)(result));
12538 }
12539 return resultobj;
12540 fail:
12541 return NULL;
12542 }
12543
12544
12545 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12546 PyObject *resultobj;
12547 wxJoystick *arg1 = (wxJoystick *) 0 ;
12548 int result;
12549 PyObject * obj0 = 0 ;
12550 char *kwnames[] = {
12551 (char *) "self", NULL
12552 };
12553
12554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12556 if (SWIG_arg_fail(1)) SWIG_fail;
12557 {
12558 PyThreadState* __tstate = wxPyBeginAllowThreads();
12559 result = (int)(arg1)->GetUMax();
12560
12561 wxPyEndAllowThreads(__tstate);
12562 if (PyErr_Occurred()) SWIG_fail;
12563 }
12564 {
12565 resultobj = SWIG_From_int((int)(result));
12566 }
12567 return resultobj;
12568 fail:
12569 return NULL;
12570 }
12571
12572
12573 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12574 PyObject *resultobj;
12575 wxJoystick *arg1 = (wxJoystick *) 0 ;
12576 int result;
12577 PyObject * obj0 = 0 ;
12578 char *kwnames[] = {
12579 (char *) "self", NULL
12580 };
12581
12582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12584 if (SWIG_arg_fail(1)) SWIG_fail;
12585 {
12586 PyThreadState* __tstate = wxPyBeginAllowThreads();
12587 result = (int)(arg1)->GetVMin();
12588
12589 wxPyEndAllowThreads(__tstate);
12590 if (PyErr_Occurred()) SWIG_fail;
12591 }
12592 {
12593 resultobj = SWIG_From_int((int)(result));
12594 }
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12602 PyObject *resultobj;
12603 wxJoystick *arg1 = (wxJoystick *) 0 ;
12604 int result;
12605 PyObject * obj0 = 0 ;
12606 char *kwnames[] = {
12607 (char *) "self", NULL
12608 };
12609
12610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12612 if (SWIG_arg_fail(1)) SWIG_fail;
12613 {
12614 PyThreadState* __tstate = wxPyBeginAllowThreads();
12615 result = (int)(arg1)->GetVMax();
12616
12617 wxPyEndAllowThreads(__tstate);
12618 if (PyErr_Occurred()) SWIG_fail;
12619 }
12620 {
12621 resultobj = SWIG_From_int((int)(result));
12622 }
12623 return resultobj;
12624 fail:
12625 return NULL;
12626 }
12627
12628
12629 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12630 PyObject *resultobj;
12631 wxJoystick *arg1 = (wxJoystick *) 0 ;
12632 bool result;
12633 PyObject * obj0 = 0 ;
12634 char *kwnames[] = {
12635 (char *) "self", NULL
12636 };
12637
12638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12640 if (SWIG_arg_fail(1)) SWIG_fail;
12641 {
12642 PyThreadState* __tstate = wxPyBeginAllowThreads();
12643 result = (bool)(arg1)->HasRudder();
12644
12645 wxPyEndAllowThreads(__tstate);
12646 if (PyErr_Occurred()) SWIG_fail;
12647 }
12648 {
12649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12650 }
12651 return resultobj;
12652 fail:
12653 return NULL;
12654 }
12655
12656
12657 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12658 PyObject *resultobj;
12659 wxJoystick *arg1 = (wxJoystick *) 0 ;
12660 bool result;
12661 PyObject * obj0 = 0 ;
12662 char *kwnames[] = {
12663 (char *) "self", NULL
12664 };
12665
12666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12668 if (SWIG_arg_fail(1)) SWIG_fail;
12669 {
12670 PyThreadState* __tstate = wxPyBeginAllowThreads();
12671 result = (bool)(arg1)->HasZ();
12672
12673 wxPyEndAllowThreads(__tstate);
12674 if (PyErr_Occurred()) SWIG_fail;
12675 }
12676 {
12677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12678 }
12679 return resultobj;
12680 fail:
12681 return NULL;
12682 }
12683
12684
12685 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12686 PyObject *resultobj;
12687 wxJoystick *arg1 = (wxJoystick *) 0 ;
12688 bool result;
12689 PyObject * obj0 = 0 ;
12690 char *kwnames[] = {
12691 (char *) "self", NULL
12692 };
12693
12694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12696 if (SWIG_arg_fail(1)) SWIG_fail;
12697 {
12698 PyThreadState* __tstate = wxPyBeginAllowThreads();
12699 result = (bool)(arg1)->HasU();
12700
12701 wxPyEndAllowThreads(__tstate);
12702 if (PyErr_Occurred()) SWIG_fail;
12703 }
12704 {
12705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12706 }
12707 return resultobj;
12708 fail:
12709 return NULL;
12710 }
12711
12712
12713 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12714 PyObject *resultobj;
12715 wxJoystick *arg1 = (wxJoystick *) 0 ;
12716 bool result;
12717 PyObject * obj0 = 0 ;
12718 char *kwnames[] = {
12719 (char *) "self", NULL
12720 };
12721
12722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12724 if (SWIG_arg_fail(1)) SWIG_fail;
12725 {
12726 PyThreadState* __tstate = wxPyBeginAllowThreads();
12727 result = (bool)(arg1)->HasV();
12728
12729 wxPyEndAllowThreads(__tstate);
12730 if (PyErr_Occurred()) SWIG_fail;
12731 }
12732 {
12733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12734 }
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12742 PyObject *resultobj;
12743 wxJoystick *arg1 = (wxJoystick *) 0 ;
12744 bool result;
12745 PyObject * obj0 = 0 ;
12746 char *kwnames[] = {
12747 (char *) "self", NULL
12748 };
12749
12750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12752 if (SWIG_arg_fail(1)) SWIG_fail;
12753 {
12754 PyThreadState* __tstate = wxPyBeginAllowThreads();
12755 result = (bool)(arg1)->HasPOV();
12756
12757 wxPyEndAllowThreads(__tstate);
12758 if (PyErr_Occurred()) SWIG_fail;
12759 }
12760 {
12761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12762 }
12763 return resultobj;
12764 fail:
12765 return NULL;
12766 }
12767
12768
12769 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12770 PyObject *resultobj;
12771 wxJoystick *arg1 = (wxJoystick *) 0 ;
12772 bool result;
12773 PyObject * obj0 = 0 ;
12774 char *kwnames[] = {
12775 (char *) "self", NULL
12776 };
12777
12778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12780 if (SWIG_arg_fail(1)) SWIG_fail;
12781 {
12782 PyThreadState* __tstate = wxPyBeginAllowThreads();
12783 result = (bool)(arg1)->HasPOV4Dir();
12784
12785 wxPyEndAllowThreads(__tstate);
12786 if (PyErr_Occurred()) SWIG_fail;
12787 }
12788 {
12789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12790 }
12791 return resultobj;
12792 fail:
12793 return NULL;
12794 }
12795
12796
12797 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12798 PyObject *resultobj;
12799 wxJoystick *arg1 = (wxJoystick *) 0 ;
12800 bool result;
12801 PyObject * obj0 = 0 ;
12802 char *kwnames[] = {
12803 (char *) "self", NULL
12804 };
12805
12806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12808 if (SWIG_arg_fail(1)) SWIG_fail;
12809 {
12810 PyThreadState* __tstate = wxPyBeginAllowThreads();
12811 result = (bool)(arg1)->HasPOVCTS();
12812
12813 wxPyEndAllowThreads(__tstate);
12814 if (PyErr_Occurred()) SWIG_fail;
12815 }
12816 {
12817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12818 }
12819 return resultobj;
12820 fail:
12821 return NULL;
12822 }
12823
12824
12825 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12826 PyObject *resultobj;
12827 wxJoystick *arg1 = (wxJoystick *) 0 ;
12828 wxWindow *arg2 = (wxWindow *) 0 ;
12829 int arg3 = (int) 0 ;
12830 bool result;
12831 PyObject * obj0 = 0 ;
12832 PyObject * obj1 = 0 ;
12833 PyObject * obj2 = 0 ;
12834 char *kwnames[] = {
12835 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12836 };
12837
12838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12840 if (SWIG_arg_fail(1)) SWIG_fail;
12841 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12842 if (SWIG_arg_fail(2)) SWIG_fail;
12843 if (obj2) {
12844 {
12845 arg3 = (int)(SWIG_As_int(obj2));
12846 if (SWIG_arg_fail(3)) SWIG_fail;
12847 }
12848 }
12849 {
12850 PyThreadState* __tstate = wxPyBeginAllowThreads();
12851 result = (bool)(arg1)->SetCapture(arg2,arg3);
12852
12853 wxPyEndAllowThreads(__tstate);
12854 if (PyErr_Occurred()) SWIG_fail;
12855 }
12856 {
12857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12858 }
12859 return resultobj;
12860 fail:
12861 return NULL;
12862 }
12863
12864
12865 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12866 PyObject *resultobj;
12867 wxJoystick *arg1 = (wxJoystick *) 0 ;
12868 bool result;
12869 PyObject * obj0 = 0 ;
12870 char *kwnames[] = {
12871 (char *) "self", NULL
12872 };
12873
12874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12876 if (SWIG_arg_fail(1)) SWIG_fail;
12877 {
12878 PyThreadState* __tstate = wxPyBeginAllowThreads();
12879 result = (bool)(arg1)->ReleaseCapture();
12880
12881 wxPyEndAllowThreads(__tstate);
12882 if (PyErr_Occurred()) SWIG_fail;
12883 }
12884 {
12885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12886 }
12887 return resultobj;
12888 fail:
12889 return NULL;
12890 }
12891
12892
12893 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12894 PyObject *obj;
12895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12896 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12897 Py_INCREF(obj);
12898 return Py_BuildValue((char *)"");
12899 }
12900 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12901 PyObject *resultobj;
12902 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12903 int arg2 = (int) 0 ;
12904 int arg3 = (int) wxJOYSTICK1 ;
12905 int arg4 = (int) 0 ;
12906 wxJoystickEvent *result;
12907 PyObject * obj0 = 0 ;
12908 PyObject * obj1 = 0 ;
12909 PyObject * obj2 = 0 ;
12910 PyObject * obj3 = 0 ;
12911 char *kwnames[] = {
12912 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12913 };
12914
12915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12916 if (obj0) {
12917 {
12918 arg1 = (wxEventType)(SWIG_As_int(obj0));
12919 if (SWIG_arg_fail(1)) SWIG_fail;
12920 }
12921 }
12922 if (obj1) {
12923 {
12924 arg2 = (int)(SWIG_As_int(obj1));
12925 if (SWIG_arg_fail(2)) SWIG_fail;
12926 }
12927 }
12928 if (obj2) {
12929 {
12930 arg3 = (int)(SWIG_As_int(obj2));
12931 if (SWIG_arg_fail(3)) SWIG_fail;
12932 }
12933 }
12934 if (obj3) {
12935 {
12936 arg4 = (int)(SWIG_As_int(obj3));
12937 if (SWIG_arg_fail(4)) SWIG_fail;
12938 }
12939 }
12940 {
12941 PyThreadState* __tstate = wxPyBeginAllowThreads();
12942 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12943
12944 wxPyEndAllowThreads(__tstate);
12945 if (PyErr_Occurred()) SWIG_fail;
12946 }
12947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12948 return resultobj;
12949 fail:
12950 return NULL;
12951 }
12952
12953
12954 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12955 PyObject *resultobj;
12956 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12957 wxPoint result;
12958 PyObject * obj0 = 0 ;
12959 char *kwnames[] = {
12960 (char *) "self", NULL
12961 };
12962
12963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12965 if (SWIG_arg_fail(1)) SWIG_fail;
12966 {
12967 PyThreadState* __tstate = wxPyBeginAllowThreads();
12968 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12969
12970 wxPyEndAllowThreads(__tstate);
12971 if (PyErr_Occurred()) SWIG_fail;
12972 }
12973 {
12974 wxPoint * resultptr;
12975 resultptr = new wxPoint((wxPoint &)(result));
12976 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12977 }
12978 return resultobj;
12979 fail:
12980 return NULL;
12981 }
12982
12983
12984 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12985 PyObject *resultobj;
12986 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12987 int result;
12988 PyObject * obj0 = 0 ;
12989 char *kwnames[] = {
12990 (char *) "self", NULL
12991 };
12992
12993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12995 if (SWIG_arg_fail(1)) SWIG_fail;
12996 {
12997 PyThreadState* __tstate = wxPyBeginAllowThreads();
12998 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12999
13000 wxPyEndAllowThreads(__tstate);
13001 if (PyErr_Occurred()) SWIG_fail;
13002 }
13003 {
13004 resultobj = SWIG_From_int((int)(result));
13005 }
13006 return resultobj;
13007 fail:
13008 return NULL;
13009 }
13010
13011
13012 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13013 PyObject *resultobj;
13014 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13015 int result;
13016 PyObject * obj0 = 0 ;
13017 char *kwnames[] = {
13018 (char *) "self", NULL
13019 };
13020
13021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13023 if (SWIG_arg_fail(1)) SWIG_fail;
13024 {
13025 PyThreadState* __tstate = wxPyBeginAllowThreads();
13026 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13027
13028 wxPyEndAllowThreads(__tstate);
13029 if (PyErr_Occurred()) SWIG_fail;
13030 }
13031 {
13032 resultobj = SWIG_From_int((int)(result));
13033 }
13034 return resultobj;
13035 fail:
13036 return NULL;
13037 }
13038
13039
13040 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13041 PyObject *resultobj;
13042 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13043 int result;
13044 PyObject * obj0 = 0 ;
13045 char *kwnames[] = {
13046 (char *) "self", NULL
13047 };
13048
13049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13051 if (SWIG_arg_fail(1)) SWIG_fail;
13052 {
13053 PyThreadState* __tstate = wxPyBeginAllowThreads();
13054 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13055
13056 wxPyEndAllowThreads(__tstate);
13057 if (PyErr_Occurred()) SWIG_fail;
13058 }
13059 {
13060 resultobj = SWIG_From_int((int)(result));
13061 }
13062 return resultobj;
13063 fail:
13064 return NULL;
13065 }
13066
13067
13068 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13069 PyObject *resultobj;
13070 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13071 int result;
13072 PyObject * obj0 = 0 ;
13073 char *kwnames[] = {
13074 (char *) "self", NULL
13075 };
13076
13077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13079 if (SWIG_arg_fail(1)) SWIG_fail;
13080 {
13081 PyThreadState* __tstate = wxPyBeginAllowThreads();
13082 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13083
13084 wxPyEndAllowThreads(__tstate);
13085 if (PyErr_Occurred()) SWIG_fail;
13086 }
13087 {
13088 resultobj = SWIG_From_int((int)(result));
13089 }
13090 return resultobj;
13091 fail:
13092 return NULL;
13093 }
13094
13095
13096 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13097 PyObject *resultobj;
13098 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13099 int arg2 ;
13100 PyObject * obj0 = 0 ;
13101 PyObject * obj1 = 0 ;
13102 char *kwnames[] = {
13103 (char *) "self",(char *) "stick", NULL
13104 };
13105
13106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13108 if (SWIG_arg_fail(1)) SWIG_fail;
13109 {
13110 arg2 = (int)(SWIG_As_int(obj1));
13111 if (SWIG_arg_fail(2)) SWIG_fail;
13112 }
13113 {
13114 PyThreadState* __tstate = wxPyBeginAllowThreads();
13115 (arg1)->SetJoystick(arg2);
13116
13117 wxPyEndAllowThreads(__tstate);
13118 if (PyErr_Occurred()) SWIG_fail;
13119 }
13120 Py_INCREF(Py_None); resultobj = Py_None;
13121 return resultobj;
13122 fail:
13123 return NULL;
13124 }
13125
13126
13127 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13128 PyObject *resultobj;
13129 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13130 int arg2 ;
13131 PyObject * obj0 = 0 ;
13132 PyObject * obj1 = 0 ;
13133 char *kwnames[] = {
13134 (char *) "self",(char *) "state", NULL
13135 };
13136
13137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13139 if (SWIG_arg_fail(1)) SWIG_fail;
13140 {
13141 arg2 = (int)(SWIG_As_int(obj1));
13142 if (SWIG_arg_fail(2)) SWIG_fail;
13143 }
13144 {
13145 PyThreadState* __tstate = wxPyBeginAllowThreads();
13146 (arg1)->SetButtonState(arg2);
13147
13148 wxPyEndAllowThreads(__tstate);
13149 if (PyErr_Occurred()) SWIG_fail;
13150 }
13151 Py_INCREF(Py_None); resultobj = Py_None;
13152 return resultobj;
13153 fail:
13154 return NULL;
13155 }
13156
13157
13158 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13159 PyObject *resultobj;
13160 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13161 int arg2 ;
13162 PyObject * obj0 = 0 ;
13163 PyObject * obj1 = 0 ;
13164 char *kwnames[] = {
13165 (char *) "self",(char *) "change", NULL
13166 };
13167
13168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13170 if (SWIG_arg_fail(1)) SWIG_fail;
13171 {
13172 arg2 = (int)(SWIG_As_int(obj1));
13173 if (SWIG_arg_fail(2)) SWIG_fail;
13174 }
13175 {
13176 PyThreadState* __tstate = wxPyBeginAllowThreads();
13177 (arg1)->SetButtonChange(arg2);
13178
13179 wxPyEndAllowThreads(__tstate);
13180 if (PyErr_Occurred()) SWIG_fail;
13181 }
13182 Py_INCREF(Py_None); resultobj = Py_None;
13183 return resultobj;
13184 fail:
13185 return NULL;
13186 }
13187
13188
13189 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13190 PyObject *resultobj;
13191 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13192 wxPoint *arg2 = 0 ;
13193 wxPoint temp2 ;
13194 PyObject * obj0 = 0 ;
13195 PyObject * obj1 = 0 ;
13196 char *kwnames[] = {
13197 (char *) "self",(char *) "pos", NULL
13198 };
13199
13200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13202 if (SWIG_arg_fail(1)) SWIG_fail;
13203 {
13204 arg2 = &temp2;
13205 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13206 }
13207 {
13208 PyThreadState* __tstate = wxPyBeginAllowThreads();
13209 (arg1)->SetPosition((wxPoint const &)*arg2);
13210
13211 wxPyEndAllowThreads(__tstate);
13212 if (PyErr_Occurred()) SWIG_fail;
13213 }
13214 Py_INCREF(Py_None); resultobj = Py_None;
13215 return resultobj;
13216 fail:
13217 return NULL;
13218 }
13219
13220
13221 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13222 PyObject *resultobj;
13223 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13224 int arg2 ;
13225 PyObject * obj0 = 0 ;
13226 PyObject * obj1 = 0 ;
13227 char *kwnames[] = {
13228 (char *) "self",(char *) "zPos", NULL
13229 };
13230
13231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13233 if (SWIG_arg_fail(1)) SWIG_fail;
13234 {
13235 arg2 = (int)(SWIG_As_int(obj1));
13236 if (SWIG_arg_fail(2)) SWIG_fail;
13237 }
13238 {
13239 PyThreadState* __tstate = wxPyBeginAllowThreads();
13240 (arg1)->SetZPosition(arg2);
13241
13242 wxPyEndAllowThreads(__tstate);
13243 if (PyErr_Occurred()) SWIG_fail;
13244 }
13245 Py_INCREF(Py_None); resultobj = Py_None;
13246 return resultobj;
13247 fail:
13248 return NULL;
13249 }
13250
13251
13252 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13253 PyObject *resultobj;
13254 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13255 bool result;
13256 PyObject * obj0 = 0 ;
13257 char *kwnames[] = {
13258 (char *) "self", NULL
13259 };
13260
13261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13263 if (SWIG_arg_fail(1)) SWIG_fail;
13264 {
13265 PyThreadState* __tstate = wxPyBeginAllowThreads();
13266 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13267
13268 wxPyEndAllowThreads(__tstate);
13269 if (PyErr_Occurred()) SWIG_fail;
13270 }
13271 {
13272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13273 }
13274 return resultobj;
13275 fail:
13276 return NULL;
13277 }
13278
13279
13280 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13281 PyObject *resultobj;
13282 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13283 bool result;
13284 PyObject * obj0 = 0 ;
13285 char *kwnames[] = {
13286 (char *) "self", NULL
13287 };
13288
13289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13291 if (SWIG_arg_fail(1)) SWIG_fail;
13292 {
13293 PyThreadState* __tstate = wxPyBeginAllowThreads();
13294 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13295
13296 wxPyEndAllowThreads(__tstate);
13297 if (PyErr_Occurred()) SWIG_fail;
13298 }
13299 {
13300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13301 }
13302 return resultobj;
13303 fail:
13304 return NULL;
13305 }
13306
13307
13308 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13309 PyObject *resultobj;
13310 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13311 bool result;
13312 PyObject * obj0 = 0 ;
13313 char *kwnames[] = {
13314 (char *) "self", NULL
13315 };
13316
13317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13319 if (SWIG_arg_fail(1)) SWIG_fail;
13320 {
13321 PyThreadState* __tstate = wxPyBeginAllowThreads();
13322 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13323
13324 wxPyEndAllowThreads(__tstate);
13325 if (PyErr_Occurred()) SWIG_fail;
13326 }
13327 {
13328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13329 }
13330 return resultobj;
13331 fail:
13332 return NULL;
13333 }
13334
13335
13336 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13337 PyObject *resultobj;
13338 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13339 int arg2 = (int) wxJOY_BUTTON_ANY ;
13340 bool result;
13341 PyObject * obj0 = 0 ;
13342 PyObject * obj1 = 0 ;
13343 char *kwnames[] = {
13344 (char *) "self",(char *) "but", NULL
13345 };
13346
13347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13349 if (SWIG_arg_fail(1)) SWIG_fail;
13350 if (obj1) {
13351 {
13352 arg2 = (int)(SWIG_As_int(obj1));
13353 if (SWIG_arg_fail(2)) SWIG_fail;
13354 }
13355 }
13356 {
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13359
13360 wxPyEndAllowThreads(__tstate);
13361 if (PyErr_Occurred()) SWIG_fail;
13362 }
13363 {
13364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13365 }
13366 return resultobj;
13367 fail:
13368 return NULL;
13369 }
13370
13371
13372 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13373 PyObject *resultobj;
13374 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13375 int arg2 = (int) wxJOY_BUTTON_ANY ;
13376 bool result;
13377 PyObject * obj0 = 0 ;
13378 PyObject * obj1 = 0 ;
13379 char *kwnames[] = {
13380 (char *) "self",(char *) "but", NULL
13381 };
13382
13383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13385 if (SWIG_arg_fail(1)) SWIG_fail;
13386 if (obj1) {
13387 {
13388 arg2 = (int)(SWIG_As_int(obj1));
13389 if (SWIG_arg_fail(2)) SWIG_fail;
13390 }
13391 }
13392 {
13393 PyThreadState* __tstate = wxPyBeginAllowThreads();
13394 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13395
13396 wxPyEndAllowThreads(__tstate);
13397 if (PyErr_Occurred()) SWIG_fail;
13398 }
13399 {
13400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13401 }
13402 return resultobj;
13403 fail:
13404 return NULL;
13405 }
13406
13407
13408 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13409 PyObject *resultobj;
13410 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13411 int arg2 = (int) wxJOY_BUTTON_ANY ;
13412 bool result;
13413 PyObject * obj0 = 0 ;
13414 PyObject * obj1 = 0 ;
13415 char *kwnames[] = {
13416 (char *) "self",(char *) "but", NULL
13417 };
13418
13419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13421 if (SWIG_arg_fail(1)) SWIG_fail;
13422 if (obj1) {
13423 {
13424 arg2 = (int)(SWIG_As_int(obj1));
13425 if (SWIG_arg_fail(2)) SWIG_fail;
13426 }
13427 }
13428 {
13429 PyThreadState* __tstate = wxPyBeginAllowThreads();
13430 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13431
13432 wxPyEndAllowThreads(__tstate);
13433 if (PyErr_Occurred()) SWIG_fail;
13434 }
13435 {
13436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13437 }
13438 return resultobj;
13439 fail:
13440 return NULL;
13441 }
13442
13443
13444 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13445 PyObject *obj;
13446 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13447 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13448 Py_INCREF(obj);
13449 return Py_BuildValue((char *)"");
13450 }
13451 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13452 PyObject *resultobj;
13453 wxString const &arg1_defvalue = wxPyEmptyString ;
13454 wxString *arg1 = (wxString *) &arg1_defvalue ;
13455 wxSound *result;
13456 bool temp1 = false ;
13457 PyObject * obj0 = 0 ;
13458 char *kwnames[] = {
13459 (char *) "fileName", NULL
13460 };
13461
13462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13463 if (obj0) {
13464 {
13465 arg1 = wxString_in_helper(obj0);
13466 if (arg1 == NULL) SWIG_fail;
13467 temp1 = true;
13468 }
13469 }
13470 {
13471 if (!wxPyCheckForApp()) SWIG_fail;
13472 PyThreadState* __tstate = wxPyBeginAllowThreads();
13473 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13474
13475 wxPyEndAllowThreads(__tstate);
13476 if (PyErr_Occurred()) SWIG_fail;
13477 }
13478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13479 {
13480 if (temp1)
13481 delete arg1;
13482 }
13483 return resultobj;
13484 fail:
13485 {
13486 if (temp1)
13487 delete arg1;
13488 }
13489 return NULL;
13490 }
13491
13492
13493 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13494 PyObject *resultobj;
13495 PyObject *arg1 = (PyObject *) 0 ;
13496 wxSound *result;
13497 PyObject * obj0 = 0 ;
13498 char *kwnames[] = {
13499 (char *) "data", NULL
13500 };
13501
13502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13503 arg1 = obj0;
13504 {
13505 if (!wxPyCheckForApp()) SWIG_fail;
13506 PyThreadState* __tstate = wxPyBeginAllowThreads();
13507 result = (wxSound *)new_wxSound(arg1);
13508
13509 wxPyEndAllowThreads(__tstate);
13510 if (PyErr_Occurred()) SWIG_fail;
13511 }
13512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13513 return resultobj;
13514 fail:
13515 return NULL;
13516 }
13517
13518
13519 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13520 PyObject *resultobj;
13521 wxSound *arg1 = (wxSound *) 0 ;
13522 PyObject * obj0 = 0 ;
13523 char *kwnames[] = {
13524 (char *) "self", NULL
13525 };
13526
13527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13529 if (SWIG_arg_fail(1)) SWIG_fail;
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 delete arg1;
13533
13534 wxPyEndAllowThreads(__tstate);
13535 if (PyErr_Occurred()) SWIG_fail;
13536 }
13537 Py_INCREF(Py_None); resultobj = Py_None;
13538 return resultobj;
13539 fail:
13540 return NULL;
13541 }
13542
13543
13544 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13545 PyObject *resultobj;
13546 wxSound *arg1 = (wxSound *) 0 ;
13547 wxString *arg2 = 0 ;
13548 bool result;
13549 bool temp2 = false ;
13550 PyObject * obj0 = 0 ;
13551 PyObject * obj1 = 0 ;
13552 char *kwnames[] = {
13553 (char *) "self",(char *) "fileName", NULL
13554 };
13555
13556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13558 if (SWIG_arg_fail(1)) SWIG_fail;
13559 {
13560 arg2 = wxString_in_helper(obj1);
13561 if (arg2 == NULL) SWIG_fail;
13562 temp2 = true;
13563 }
13564 {
13565 PyThreadState* __tstate = wxPyBeginAllowThreads();
13566 result = (bool)(arg1)->Create((wxString const &)*arg2);
13567
13568 wxPyEndAllowThreads(__tstate);
13569 if (PyErr_Occurred()) SWIG_fail;
13570 }
13571 {
13572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13573 }
13574 {
13575 if (temp2)
13576 delete arg2;
13577 }
13578 return resultobj;
13579 fail:
13580 {
13581 if (temp2)
13582 delete arg2;
13583 }
13584 return NULL;
13585 }
13586
13587
13588 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13589 PyObject *resultobj;
13590 wxSound *arg1 = (wxSound *) 0 ;
13591 PyObject *arg2 = (PyObject *) 0 ;
13592 bool result;
13593 PyObject * obj0 = 0 ;
13594 PyObject * obj1 = 0 ;
13595 char *kwnames[] = {
13596 (char *) "self",(char *) "data", NULL
13597 };
13598
13599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13601 if (SWIG_arg_fail(1)) SWIG_fail;
13602 arg2 = obj1;
13603 {
13604 PyThreadState* __tstate = wxPyBeginAllowThreads();
13605 result = (bool)wxSound_CreateFromData(arg1,arg2);
13606
13607 wxPyEndAllowThreads(__tstate);
13608 if (PyErr_Occurred()) SWIG_fail;
13609 }
13610 {
13611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13612 }
13613 return resultobj;
13614 fail:
13615 return NULL;
13616 }
13617
13618
13619 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13620 PyObject *resultobj;
13621 wxSound *arg1 = (wxSound *) 0 ;
13622 bool result;
13623 PyObject * obj0 = 0 ;
13624 char *kwnames[] = {
13625 (char *) "self", NULL
13626 };
13627
13628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13630 if (SWIG_arg_fail(1)) SWIG_fail;
13631 {
13632 PyThreadState* __tstate = wxPyBeginAllowThreads();
13633 result = (bool)(arg1)->IsOk();
13634
13635 wxPyEndAllowThreads(__tstate);
13636 if (PyErr_Occurred()) SWIG_fail;
13637 }
13638 {
13639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13640 }
13641 return resultobj;
13642 fail:
13643 return NULL;
13644 }
13645
13646
13647 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13648 PyObject *resultobj;
13649 wxSound *arg1 = (wxSound *) 0 ;
13650 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13651 bool result;
13652 PyObject * obj0 = 0 ;
13653 PyObject * obj1 = 0 ;
13654 char *kwnames[] = {
13655 (char *) "self",(char *) "flags", NULL
13656 };
13657
13658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13660 if (SWIG_arg_fail(1)) SWIG_fail;
13661 if (obj1) {
13662 {
13663 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13664 if (SWIG_arg_fail(2)) SWIG_fail;
13665 }
13666 }
13667 {
13668 if (!wxPyCheckForApp()) SWIG_fail;
13669 PyThreadState* __tstate = wxPyBeginAllowThreads();
13670 result = (bool)((wxSound const *)arg1)->Play(arg2);
13671
13672 wxPyEndAllowThreads(__tstate);
13673 if (PyErr_Occurred()) SWIG_fail;
13674 }
13675 {
13676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13677 }
13678 return resultobj;
13679 fail:
13680 return NULL;
13681 }
13682
13683
13684 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13685 PyObject *resultobj;
13686 wxString *arg1 = 0 ;
13687 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13688 bool result;
13689 bool temp1 = false ;
13690 PyObject * obj0 = 0 ;
13691 PyObject * obj1 = 0 ;
13692 char *kwnames[] = {
13693 (char *) "filename",(char *) "flags", NULL
13694 };
13695
13696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13697 {
13698 arg1 = wxString_in_helper(obj0);
13699 if (arg1 == NULL) SWIG_fail;
13700 temp1 = true;
13701 }
13702 if (obj1) {
13703 {
13704 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13705 if (SWIG_arg_fail(2)) SWIG_fail;
13706 }
13707 }
13708 {
13709 if (!wxPyCheckForApp()) SWIG_fail;
13710 PyThreadState* __tstate = wxPyBeginAllowThreads();
13711 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13712
13713 wxPyEndAllowThreads(__tstate);
13714 if (PyErr_Occurred()) SWIG_fail;
13715 }
13716 {
13717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13718 }
13719 {
13720 if (temp1)
13721 delete arg1;
13722 }
13723 return resultobj;
13724 fail:
13725 {
13726 if (temp1)
13727 delete arg1;
13728 }
13729 return NULL;
13730 }
13731
13732
13733 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj;
13735 char *kwnames[] = {
13736 NULL
13737 };
13738
13739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13740 {
13741 if (!wxPyCheckForApp()) SWIG_fail;
13742 PyThreadState* __tstate = wxPyBeginAllowThreads();
13743 wxSound::Stop();
13744
13745 wxPyEndAllowThreads(__tstate);
13746 if (PyErr_Occurred()) SWIG_fail;
13747 }
13748 Py_INCREF(Py_None); resultobj = Py_None;
13749 return resultobj;
13750 fail:
13751 return NULL;
13752 }
13753
13754
13755 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13756 PyObject *obj;
13757 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13758 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13759 Py_INCREF(obj);
13760 return Py_BuildValue((char *)"");
13761 }
13762 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13763 PyObject *resultobj;
13764 wxString *arg1 = 0 ;
13765 wxString *arg2 = 0 ;
13766 wxString *arg3 = 0 ;
13767 wxString *arg4 = 0 ;
13768 wxFileTypeInfo *result;
13769 bool temp1 = false ;
13770 bool temp2 = false ;
13771 bool temp3 = false ;
13772 bool temp4 = false ;
13773 PyObject * obj0 = 0 ;
13774 PyObject * obj1 = 0 ;
13775 PyObject * obj2 = 0 ;
13776 PyObject * obj3 = 0 ;
13777 char *kwnames[] = {
13778 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13779 };
13780
13781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13782 {
13783 arg1 = wxString_in_helper(obj0);
13784 if (arg1 == NULL) SWIG_fail;
13785 temp1 = true;
13786 }
13787 {
13788 arg2 = wxString_in_helper(obj1);
13789 if (arg2 == NULL) SWIG_fail;
13790 temp2 = true;
13791 }
13792 {
13793 arg3 = wxString_in_helper(obj2);
13794 if (arg3 == NULL) SWIG_fail;
13795 temp3 = true;
13796 }
13797 {
13798 arg4 = wxString_in_helper(obj3);
13799 if (arg4 == NULL) SWIG_fail;
13800 temp4 = true;
13801 }
13802 {
13803 PyThreadState* __tstate = wxPyBeginAllowThreads();
13804 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13805
13806 wxPyEndAllowThreads(__tstate);
13807 if (PyErr_Occurred()) SWIG_fail;
13808 }
13809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13810 {
13811 if (temp1)
13812 delete arg1;
13813 }
13814 {
13815 if (temp2)
13816 delete arg2;
13817 }
13818 {
13819 if (temp3)
13820 delete arg3;
13821 }
13822 {
13823 if (temp4)
13824 delete arg4;
13825 }
13826 return resultobj;
13827 fail:
13828 {
13829 if (temp1)
13830 delete arg1;
13831 }
13832 {
13833 if (temp2)
13834 delete arg2;
13835 }
13836 {
13837 if (temp3)
13838 delete arg3;
13839 }
13840 {
13841 if (temp4)
13842 delete arg4;
13843 }
13844 return NULL;
13845 }
13846
13847
13848 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13849 PyObject *resultobj;
13850 wxArrayString *arg1 = 0 ;
13851 wxFileTypeInfo *result;
13852 bool temp1 = false ;
13853 PyObject * obj0 = 0 ;
13854 char *kwnames[] = {
13855 (char *) "sArray", NULL
13856 };
13857
13858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13859 {
13860 if (! PySequence_Check(obj0)) {
13861 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13862 SWIG_fail;
13863 }
13864 arg1 = new wxArrayString;
13865 temp1 = true;
13866 int i, len=PySequence_Length(obj0);
13867 for (i=0; i<len; i++) {
13868 PyObject* item = PySequence_GetItem(obj0, i);
13869 wxString* s = wxString_in_helper(item);
13870 if (PyErr_Occurred()) SWIG_fail;
13871 arg1->Add(*s);
13872 delete s;
13873 Py_DECREF(item);
13874 }
13875 }
13876 {
13877 PyThreadState* __tstate = wxPyBeginAllowThreads();
13878 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13879
13880 wxPyEndAllowThreads(__tstate);
13881 if (PyErr_Occurred()) SWIG_fail;
13882 }
13883 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13884 {
13885 if (temp1) delete arg1;
13886 }
13887 return resultobj;
13888 fail:
13889 {
13890 if (temp1) delete arg1;
13891 }
13892 return NULL;
13893 }
13894
13895
13896 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13897 PyObject *resultobj;
13898 wxFileTypeInfo *result;
13899 char *kwnames[] = {
13900 NULL
13901 };
13902
13903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13904 {
13905 PyThreadState* __tstate = wxPyBeginAllowThreads();
13906 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13907
13908 wxPyEndAllowThreads(__tstate);
13909 if (PyErr_Occurred()) SWIG_fail;
13910 }
13911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13912 return resultobj;
13913 fail:
13914 return NULL;
13915 }
13916
13917
13918 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13919 PyObject *resultobj;
13920 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13921 bool result;
13922 PyObject * obj0 = 0 ;
13923 char *kwnames[] = {
13924 (char *) "self", NULL
13925 };
13926
13927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13929 if (SWIG_arg_fail(1)) SWIG_fail;
13930 {
13931 PyThreadState* __tstate = wxPyBeginAllowThreads();
13932 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13933
13934 wxPyEndAllowThreads(__tstate);
13935 if (PyErr_Occurred()) SWIG_fail;
13936 }
13937 {
13938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13939 }
13940 return resultobj;
13941 fail:
13942 return NULL;
13943 }
13944
13945
13946 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13947 PyObject *resultobj;
13948 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13949 wxString *arg2 = 0 ;
13950 int arg3 = (int) 0 ;
13951 bool temp2 = false ;
13952 PyObject * obj0 = 0 ;
13953 PyObject * obj1 = 0 ;
13954 PyObject * obj2 = 0 ;
13955 char *kwnames[] = {
13956 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13957 };
13958
13959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13961 if (SWIG_arg_fail(1)) SWIG_fail;
13962 {
13963 arg2 = wxString_in_helper(obj1);
13964 if (arg2 == NULL) SWIG_fail;
13965 temp2 = true;
13966 }
13967 if (obj2) {
13968 {
13969 arg3 = (int)(SWIG_As_int(obj2));
13970 if (SWIG_arg_fail(3)) SWIG_fail;
13971 }
13972 }
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13976
13977 wxPyEndAllowThreads(__tstate);
13978 if (PyErr_Occurred()) SWIG_fail;
13979 }
13980 Py_INCREF(Py_None); resultobj = Py_None;
13981 {
13982 if (temp2)
13983 delete arg2;
13984 }
13985 return resultobj;
13986 fail:
13987 {
13988 if (temp2)
13989 delete arg2;
13990 }
13991 return NULL;
13992 }
13993
13994
13995 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13996 PyObject *resultobj;
13997 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13998 wxString *arg2 = 0 ;
13999 bool temp2 = false ;
14000 PyObject * obj0 = 0 ;
14001 PyObject * obj1 = 0 ;
14002 char *kwnames[] = {
14003 (char *) "self",(char *) "shortDesc", NULL
14004 };
14005
14006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14008 if (SWIG_arg_fail(1)) SWIG_fail;
14009 {
14010 arg2 = wxString_in_helper(obj1);
14011 if (arg2 == NULL) SWIG_fail;
14012 temp2 = true;
14013 }
14014 {
14015 PyThreadState* __tstate = wxPyBeginAllowThreads();
14016 (arg1)->SetShortDesc((wxString const &)*arg2);
14017
14018 wxPyEndAllowThreads(__tstate);
14019 if (PyErr_Occurred()) SWIG_fail;
14020 }
14021 Py_INCREF(Py_None); resultobj = Py_None;
14022 {
14023 if (temp2)
14024 delete arg2;
14025 }
14026 return resultobj;
14027 fail:
14028 {
14029 if (temp2)
14030 delete arg2;
14031 }
14032 return NULL;
14033 }
14034
14035
14036 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14037 PyObject *resultobj;
14038 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14039 wxString *result;
14040 PyObject * obj0 = 0 ;
14041 char *kwnames[] = {
14042 (char *) "self", NULL
14043 };
14044
14045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14047 if (SWIG_arg_fail(1)) SWIG_fail;
14048 {
14049 PyThreadState* __tstate = wxPyBeginAllowThreads();
14050 {
14051 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14052 result = (wxString *) &_result_ref;
14053 }
14054
14055 wxPyEndAllowThreads(__tstate);
14056 if (PyErr_Occurred()) SWIG_fail;
14057 }
14058 {
14059 #if wxUSE_UNICODE
14060 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14061 #else
14062 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14063 #endif
14064 }
14065 return resultobj;
14066 fail:
14067 return NULL;
14068 }
14069
14070
14071 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14072 PyObject *resultobj;
14073 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14074 wxString *result;
14075 PyObject * obj0 = 0 ;
14076 char *kwnames[] = {
14077 (char *) "self", NULL
14078 };
14079
14080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14082 if (SWIG_arg_fail(1)) SWIG_fail;
14083 {
14084 PyThreadState* __tstate = wxPyBeginAllowThreads();
14085 {
14086 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14087 result = (wxString *) &_result_ref;
14088 }
14089
14090 wxPyEndAllowThreads(__tstate);
14091 if (PyErr_Occurred()) SWIG_fail;
14092 }
14093 {
14094 #if wxUSE_UNICODE
14095 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14096 #else
14097 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14098 #endif
14099 }
14100 return resultobj;
14101 fail:
14102 return NULL;
14103 }
14104
14105
14106 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14107 PyObject *resultobj;
14108 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14109 wxString *result;
14110 PyObject * obj0 = 0 ;
14111 char *kwnames[] = {
14112 (char *) "self", NULL
14113 };
14114
14115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14117 if (SWIG_arg_fail(1)) SWIG_fail;
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 {
14121 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14122 result = (wxString *) &_result_ref;
14123 }
14124
14125 wxPyEndAllowThreads(__tstate);
14126 if (PyErr_Occurred()) SWIG_fail;
14127 }
14128 {
14129 #if wxUSE_UNICODE
14130 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14131 #else
14132 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14133 #endif
14134 }
14135 return resultobj;
14136 fail:
14137 return NULL;
14138 }
14139
14140
14141 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14142 PyObject *resultobj;
14143 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14144 wxString *result;
14145 PyObject * obj0 = 0 ;
14146 char *kwnames[] = {
14147 (char *) "self", NULL
14148 };
14149
14150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14152 if (SWIG_arg_fail(1)) SWIG_fail;
14153 {
14154 PyThreadState* __tstate = wxPyBeginAllowThreads();
14155 {
14156 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14157 result = (wxString *) &_result_ref;
14158 }
14159
14160 wxPyEndAllowThreads(__tstate);
14161 if (PyErr_Occurred()) SWIG_fail;
14162 }
14163 {
14164 #if wxUSE_UNICODE
14165 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14166 #else
14167 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14168 #endif
14169 }
14170 return resultobj;
14171 fail:
14172 return NULL;
14173 }
14174
14175
14176 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14177 PyObject *resultobj;
14178 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14179 wxString *result;
14180 PyObject * obj0 = 0 ;
14181 char *kwnames[] = {
14182 (char *) "self", NULL
14183 };
14184
14185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14187 if (SWIG_arg_fail(1)) SWIG_fail;
14188 {
14189 PyThreadState* __tstate = wxPyBeginAllowThreads();
14190 {
14191 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14192 result = (wxString *) &_result_ref;
14193 }
14194
14195 wxPyEndAllowThreads(__tstate);
14196 if (PyErr_Occurred()) SWIG_fail;
14197 }
14198 {
14199 #if wxUSE_UNICODE
14200 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14201 #else
14202 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14203 #endif
14204 }
14205 return resultobj;
14206 fail:
14207 return NULL;
14208 }
14209
14210
14211 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14212 PyObject *resultobj;
14213 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14214 wxArrayString *result;
14215 PyObject * obj0 = 0 ;
14216 char *kwnames[] = {
14217 (char *) "self", NULL
14218 };
14219
14220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14222 if (SWIG_arg_fail(1)) SWIG_fail;
14223 {
14224 PyThreadState* __tstate = wxPyBeginAllowThreads();
14225 {
14226 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14227 result = (wxArrayString *) &_result_ref;
14228 }
14229
14230 wxPyEndAllowThreads(__tstate);
14231 if (PyErr_Occurred()) SWIG_fail;
14232 }
14233 {
14234 resultobj = wxArrayString2PyList_helper(*result);
14235 }
14236 return resultobj;
14237 fail:
14238 return NULL;
14239 }
14240
14241
14242 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14243 PyObject *resultobj;
14244 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14245 int result;
14246 PyObject * obj0 = 0 ;
14247 char *kwnames[] = {
14248 (char *) "self", NULL
14249 };
14250
14251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14253 if (SWIG_arg_fail(1)) SWIG_fail;
14254 {
14255 PyThreadState* __tstate = wxPyBeginAllowThreads();
14256 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14257
14258 wxPyEndAllowThreads(__tstate);
14259 if (PyErr_Occurred()) SWIG_fail;
14260 }
14261 {
14262 resultobj = SWIG_From_int((int)(result));
14263 }
14264 return resultobj;
14265 fail:
14266 return NULL;
14267 }
14268
14269
14270 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14271 PyObject *resultobj;
14272 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14273 wxString *result;
14274 PyObject * obj0 = 0 ;
14275 char *kwnames[] = {
14276 (char *) "self", NULL
14277 };
14278
14279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14281 if (SWIG_arg_fail(1)) SWIG_fail;
14282 {
14283 PyThreadState* __tstate = wxPyBeginAllowThreads();
14284 {
14285 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14286 result = (wxString *) &_result_ref;
14287 }
14288
14289 wxPyEndAllowThreads(__tstate);
14290 if (PyErr_Occurred()) SWIG_fail;
14291 }
14292 {
14293 #if wxUSE_UNICODE
14294 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14295 #else
14296 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14297 #endif
14298 }
14299 return resultobj;
14300 fail:
14301 return NULL;
14302 }
14303
14304
14305 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14306 PyObject *resultobj;
14307 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14308 int result;
14309 PyObject * obj0 = 0 ;
14310 char *kwnames[] = {
14311 (char *) "self", NULL
14312 };
14313
14314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14316 if (SWIG_arg_fail(1)) SWIG_fail;
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14320
14321 wxPyEndAllowThreads(__tstate);
14322 if (PyErr_Occurred()) SWIG_fail;
14323 }
14324 {
14325 resultobj = SWIG_From_int((int)(result));
14326 }
14327 return resultobj;
14328 fail:
14329 return NULL;
14330 }
14331
14332
14333 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14334 PyObject *obj;
14335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14336 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14337 Py_INCREF(obj);
14338 return Py_BuildValue((char *)"");
14339 }
14340 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj;
14342 wxFileTypeInfo *arg1 = 0 ;
14343 wxFileType *result;
14344 PyObject * obj0 = 0 ;
14345 char *kwnames[] = {
14346 (char *) "ftInfo", NULL
14347 };
14348
14349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14350 {
14351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14352 if (SWIG_arg_fail(1)) SWIG_fail;
14353 if (arg1 == NULL) {
14354 SWIG_null_ref("wxFileTypeInfo");
14355 }
14356 if (SWIG_arg_fail(1)) SWIG_fail;
14357 }
14358 {
14359 PyThreadState* __tstate = wxPyBeginAllowThreads();
14360 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14361
14362 wxPyEndAllowThreads(__tstate);
14363 if (PyErr_Occurred()) SWIG_fail;
14364 }
14365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14366 return resultobj;
14367 fail:
14368 return NULL;
14369 }
14370
14371
14372 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14373 PyObject *resultobj;
14374 wxFileType *arg1 = (wxFileType *) 0 ;
14375 PyObject * obj0 = 0 ;
14376 char *kwnames[] = {
14377 (char *) "self", NULL
14378 };
14379
14380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14382 if (SWIG_arg_fail(1)) SWIG_fail;
14383 {
14384 PyThreadState* __tstate = wxPyBeginAllowThreads();
14385 delete arg1;
14386
14387 wxPyEndAllowThreads(__tstate);
14388 if (PyErr_Occurred()) SWIG_fail;
14389 }
14390 Py_INCREF(Py_None); resultobj = Py_None;
14391 return resultobj;
14392 fail:
14393 return NULL;
14394 }
14395
14396
14397 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14398 PyObject *resultobj;
14399 wxFileType *arg1 = (wxFileType *) 0 ;
14400 PyObject *result;
14401 PyObject * obj0 = 0 ;
14402 char *kwnames[] = {
14403 (char *) "self", NULL
14404 };
14405
14406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14408 if (SWIG_arg_fail(1)) SWIG_fail;
14409 {
14410 PyThreadState* __tstate = wxPyBeginAllowThreads();
14411 result = (PyObject *)wxFileType_GetMimeType(arg1);
14412
14413 wxPyEndAllowThreads(__tstate);
14414 if (PyErr_Occurred()) SWIG_fail;
14415 }
14416 resultobj = result;
14417 return resultobj;
14418 fail:
14419 return NULL;
14420 }
14421
14422
14423 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14424 PyObject *resultobj;
14425 wxFileType *arg1 = (wxFileType *) 0 ;
14426 PyObject *result;
14427 PyObject * obj0 = 0 ;
14428 char *kwnames[] = {
14429 (char *) "self", NULL
14430 };
14431
14432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14434 if (SWIG_arg_fail(1)) SWIG_fail;
14435 {
14436 PyThreadState* __tstate = wxPyBeginAllowThreads();
14437 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14438
14439 wxPyEndAllowThreads(__tstate);
14440 if (PyErr_Occurred()) SWIG_fail;
14441 }
14442 resultobj = result;
14443 return resultobj;
14444 fail:
14445 return NULL;
14446 }
14447
14448
14449 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14450 PyObject *resultobj;
14451 wxFileType *arg1 = (wxFileType *) 0 ;
14452 PyObject *result;
14453 PyObject * obj0 = 0 ;
14454 char *kwnames[] = {
14455 (char *) "self", NULL
14456 };
14457
14458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14460 if (SWIG_arg_fail(1)) SWIG_fail;
14461 {
14462 PyThreadState* __tstate = wxPyBeginAllowThreads();
14463 result = (PyObject *)wxFileType_GetExtensions(arg1);
14464
14465 wxPyEndAllowThreads(__tstate);
14466 if (PyErr_Occurred()) SWIG_fail;
14467 }
14468 resultobj = result;
14469 return resultobj;
14470 fail:
14471 return NULL;
14472 }
14473
14474
14475 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14476 PyObject *resultobj;
14477 wxFileType *arg1 = (wxFileType *) 0 ;
14478 wxIcon *result;
14479 PyObject * obj0 = 0 ;
14480 char *kwnames[] = {
14481 (char *) "self", NULL
14482 };
14483
14484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14486 if (SWIG_arg_fail(1)) SWIG_fail;
14487 {
14488 PyThreadState* __tstate = wxPyBeginAllowThreads();
14489 result = (wxIcon *)wxFileType_GetIcon(arg1);
14490
14491 wxPyEndAllowThreads(__tstate);
14492 if (PyErr_Occurred()) SWIG_fail;
14493 }
14494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14495 return resultobj;
14496 fail:
14497 return NULL;
14498 }
14499
14500
14501 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14502 PyObject *resultobj;
14503 wxFileType *arg1 = (wxFileType *) 0 ;
14504 PyObject *result;
14505 PyObject * obj0 = 0 ;
14506 char *kwnames[] = {
14507 (char *) "self", NULL
14508 };
14509
14510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14512 if (SWIG_arg_fail(1)) SWIG_fail;
14513 {
14514 PyThreadState* __tstate = wxPyBeginAllowThreads();
14515 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14516
14517 wxPyEndAllowThreads(__tstate);
14518 if (PyErr_Occurred()) SWIG_fail;
14519 }
14520 resultobj = result;
14521 return resultobj;
14522 fail:
14523 return NULL;
14524 }
14525
14526
14527 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14528 PyObject *resultobj;
14529 wxFileType *arg1 = (wxFileType *) 0 ;
14530 PyObject *result;
14531 PyObject * obj0 = 0 ;
14532 char *kwnames[] = {
14533 (char *) "self", NULL
14534 };
14535
14536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14538 if (SWIG_arg_fail(1)) SWIG_fail;
14539 {
14540 PyThreadState* __tstate = wxPyBeginAllowThreads();
14541 result = (PyObject *)wxFileType_GetDescription(arg1);
14542
14543 wxPyEndAllowThreads(__tstate);
14544 if (PyErr_Occurred()) SWIG_fail;
14545 }
14546 resultobj = result;
14547 return resultobj;
14548 fail:
14549 return NULL;
14550 }
14551
14552
14553 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14554 PyObject *resultobj;
14555 wxFileType *arg1 = (wxFileType *) 0 ;
14556 wxString *arg2 = 0 ;
14557 wxString const &arg3_defvalue = wxPyEmptyString ;
14558 wxString *arg3 = (wxString *) &arg3_defvalue ;
14559 PyObject *result;
14560 bool temp2 = false ;
14561 bool temp3 = false ;
14562 PyObject * obj0 = 0 ;
14563 PyObject * obj1 = 0 ;
14564 PyObject * obj2 = 0 ;
14565 char *kwnames[] = {
14566 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14567 };
14568
14569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14571 if (SWIG_arg_fail(1)) SWIG_fail;
14572 {
14573 arg2 = wxString_in_helper(obj1);
14574 if (arg2 == NULL) SWIG_fail;
14575 temp2 = true;
14576 }
14577 if (obj2) {
14578 {
14579 arg3 = wxString_in_helper(obj2);
14580 if (arg3 == NULL) SWIG_fail;
14581 temp3 = true;
14582 }
14583 }
14584 {
14585 PyThreadState* __tstate = wxPyBeginAllowThreads();
14586 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14587
14588 wxPyEndAllowThreads(__tstate);
14589 if (PyErr_Occurred()) SWIG_fail;
14590 }
14591 resultobj = result;
14592 {
14593 if (temp2)
14594 delete arg2;
14595 }
14596 {
14597 if (temp3)
14598 delete arg3;
14599 }
14600 return resultobj;
14601 fail:
14602 {
14603 if (temp2)
14604 delete arg2;
14605 }
14606 {
14607 if (temp3)
14608 delete arg3;
14609 }
14610 return NULL;
14611 }
14612
14613
14614 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14615 PyObject *resultobj;
14616 wxFileType *arg1 = (wxFileType *) 0 ;
14617 wxString *arg2 = 0 ;
14618 wxString const &arg3_defvalue = wxPyEmptyString ;
14619 wxString *arg3 = (wxString *) &arg3_defvalue ;
14620 PyObject *result;
14621 bool temp2 = false ;
14622 bool temp3 = false ;
14623 PyObject * obj0 = 0 ;
14624 PyObject * obj1 = 0 ;
14625 PyObject * obj2 = 0 ;
14626 char *kwnames[] = {
14627 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14628 };
14629
14630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14632 if (SWIG_arg_fail(1)) SWIG_fail;
14633 {
14634 arg2 = wxString_in_helper(obj1);
14635 if (arg2 == NULL) SWIG_fail;
14636 temp2 = true;
14637 }
14638 if (obj2) {
14639 {
14640 arg3 = wxString_in_helper(obj2);
14641 if (arg3 == NULL) SWIG_fail;
14642 temp3 = true;
14643 }
14644 }
14645 {
14646 PyThreadState* __tstate = wxPyBeginAllowThreads();
14647 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14648
14649 wxPyEndAllowThreads(__tstate);
14650 if (PyErr_Occurred()) SWIG_fail;
14651 }
14652 resultobj = result;
14653 {
14654 if (temp2)
14655 delete arg2;
14656 }
14657 {
14658 if (temp3)
14659 delete arg3;
14660 }
14661 return resultobj;
14662 fail:
14663 {
14664 if (temp2)
14665 delete arg2;
14666 }
14667 {
14668 if (temp3)
14669 delete arg3;
14670 }
14671 return NULL;
14672 }
14673
14674
14675 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14676 PyObject *resultobj;
14677 wxFileType *arg1 = (wxFileType *) 0 ;
14678 wxString *arg2 = 0 ;
14679 wxString const &arg3_defvalue = wxPyEmptyString ;
14680 wxString *arg3 = (wxString *) &arg3_defvalue ;
14681 PyObject *result;
14682 bool temp2 = false ;
14683 bool temp3 = false ;
14684 PyObject * obj0 = 0 ;
14685 PyObject * obj1 = 0 ;
14686 PyObject * obj2 = 0 ;
14687 char *kwnames[] = {
14688 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14689 };
14690
14691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14693 if (SWIG_arg_fail(1)) SWIG_fail;
14694 {
14695 arg2 = wxString_in_helper(obj1);
14696 if (arg2 == NULL) SWIG_fail;
14697 temp2 = true;
14698 }
14699 if (obj2) {
14700 {
14701 arg3 = wxString_in_helper(obj2);
14702 if (arg3 == NULL) SWIG_fail;
14703 temp3 = true;
14704 }
14705 }
14706 {
14707 PyThreadState* __tstate = wxPyBeginAllowThreads();
14708 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14709
14710 wxPyEndAllowThreads(__tstate);
14711 if (PyErr_Occurred()) SWIG_fail;
14712 }
14713 resultobj = result;
14714 {
14715 if (temp2)
14716 delete arg2;
14717 }
14718 {
14719 if (temp3)
14720 delete arg3;
14721 }
14722 return resultobj;
14723 fail:
14724 {
14725 if (temp2)
14726 delete arg2;
14727 }
14728 {
14729 if (temp3)
14730 delete arg3;
14731 }
14732 return NULL;
14733 }
14734
14735
14736 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14737 PyObject *resultobj;
14738 wxFileType *arg1 = (wxFileType *) 0 ;
14739 wxString *arg2 = 0 ;
14740 wxString *arg3 = 0 ;
14741 bool arg4 = (bool) true ;
14742 bool result;
14743 bool temp2 = false ;
14744 bool temp3 = false ;
14745 PyObject * obj0 = 0 ;
14746 PyObject * obj1 = 0 ;
14747 PyObject * obj2 = 0 ;
14748 PyObject * obj3 = 0 ;
14749 char *kwnames[] = {
14750 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14751 };
14752
14753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14755 if (SWIG_arg_fail(1)) SWIG_fail;
14756 {
14757 arg2 = wxString_in_helper(obj1);
14758 if (arg2 == NULL) SWIG_fail;
14759 temp2 = true;
14760 }
14761 {
14762 arg3 = wxString_in_helper(obj2);
14763 if (arg3 == NULL) SWIG_fail;
14764 temp3 = true;
14765 }
14766 if (obj3) {
14767 {
14768 arg4 = (bool)(SWIG_As_bool(obj3));
14769 if (SWIG_arg_fail(4)) SWIG_fail;
14770 }
14771 }
14772 {
14773 PyThreadState* __tstate = wxPyBeginAllowThreads();
14774 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14775
14776 wxPyEndAllowThreads(__tstate);
14777 if (PyErr_Occurred()) SWIG_fail;
14778 }
14779 {
14780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14781 }
14782 {
14783 if (temp2)
14784 delete arg2;
14785 }
14786 {
14787 if (temp3)
14788 delete arg3;
14789 }
14790 return resultobj;
14791 fail:
14792 {
14793 if (temp2)
14794 delete arg2;
14795 }
14796 {
14797 if (temp3)
14798 delete arg3;
14799 }
14800 return NULL;
14801 }
14802
14803
14804 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14805 PyObject *resultobj;
14806 wxFileType *arg1 = (wxFileType *) 0 ;
14807 wxString const &arg2_defvalue = wxPyEmptyString ;
14808 wxString *arg2 = (wxString *) &arg2_defvalue ;
14809 int arg3 = (int) 0 ;
14810 bool result;
14811 bool temp2 = false ;
14812 PyObject * obj0 = 0 ;
14813 PyObject * obj1 = 0 ;
14814 PyObject * obj2 = 0 ;
14815 char *kwnames[] = {
14816 (char *) "self",(char *) "cmd",(char *) "index", NULL
14817 };
14818
14819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14821 if (SWIG_arg_fail(1)) SWIG_fail;
14822 if (obj1) {
14823 {
14824 arg2 = wxString_in_helper(obj1);
14825 if (arg2 == NULL) SWIG_fail;
14826 temp2 = true;
14827 }
14828 }
14829 if (obj2) {
14830 {
14831 arg3 = (int)(SWIG_As_int(obj2));
14832 if (SWIG_arg_fail(3)) SWIG_fail;
14833 }
14834 }
14835 {
14836 PyThreadState* __tstate = wxPyBeginAllowThreads();
14837 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14838
14839 wxPyEndAllowThreads(__tstate);
14840 if (PyErr_Occurred()) SWIG_fail;
14841 }
14842 {
14843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14844 }
14845 {
14846 if (temp2)
14847 delete arg2;
14848 }
14849 return resultobj;
14850 fail:
14851 {
14852 if (temp2)
14853 delete arg2;
14854 }
14855 return NULL;
14856 }
14857
14858
14859 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14860 PyObject *resultobj;
14861 wxFileType *arg1 = (wxFileType *) 0 ;
14862 bool result;
14863 PyObject * obj0 = 0 ;
14864 char *kwnames[] = {
14865 (char *) "self", NULL
14866 };
14867
14868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14870 if (SWIG_arg_fail(1)) SWIG_fail;
14871 {
14872 PyThreadState* __tstate = wxPyBeginAllowThreads();
14873 result = (bool)(arg1)->Unassociate();
14874
14875 wxPyEndAllowThreads(__tstate);
14876 if (PyErr_Occurred()) SWIG_fail;
14877 }
14878 {
14879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14880 }
14881 return resultobj;
14882 fail:
14883 return NULL;
14884 }
14885
14886
14887 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14888 PyObject *resultobj;
14889 wxString *arg1 = 0 ;
14890 wxString *arg2 = 0 ;
14891 wxString const &arg3_defvalue = wxPyEmptyString ;
14892 wxString *arg3 = (wxString *) &arg3_defvalue ;
14893 wxString result;
14894 bool temp1 = false ;
14895 bool temp2 = false ;
14896 bool temp3 = false ;
14897 PyObject * obj0 = 0 ;
14898 PyObject * obj1 = 0 ;
14899 PyObject * obj2 = 0 ;
14900 char *kwnames[] = {
14901 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14902 };
14903
14904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14905 {
14906 arg1 = wxString_in_helper(obj0);
14907 if (arg1 == NULL) SWIG_fail;
14908 temp1 = true;
14909 }
14910 {
14911 arg2 = wxString_in_helper(obj1);
14912 if (arg2 == NULL) SWIG_fail;
14913 temp2 = true;
14914 }
14915 if (obj2) {
14916 {
14917 arg3 = wxString_in_helper(obj2);
14918 if (arg3 == NULL) SWIG_fail;
14919 temp3 = true;
14920 }
14921 }
14922 {
14923 PyThreadState* __tstate = wxPyBeginAllowThreads();
14924 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14925
14926 wxPyEndAllowThreads(__tstate);
14927 if (PyErr_Occurred()) SWIG_fail;
14928 }
14929 {
14930 #if wxUSE_UNICODE
14931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14932 #else
14933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14934 #endif
14935 }
14936 {
14937 if (temp1)
14938 delete arg1;
14939 }
14940 {
14941 if (temp2)
14942 delete arg2;
14943 }
14944 {
14945 if (temp3)
14946 delete arg3;
14947 }
14948 return resultobj;
14949 fail:
14950 {
14951 if (temp1)
14952 delete arg1;
14953 }
14954 {
14955 if (temp2)
14956 delete arg2;
14957 }
14958 {
14959 if (temp3)
14960 delete arg3;
14961 }
14962 return NULL;
14963 }
14964
14965
14966 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14967 PyObject *obj;
14968 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14969 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14970 Py_INCREF(obj);
14971 return Py_BuildValue((char *)"");
14972 }
14973 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14974 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14975 return 1;
14976 }
14977
14978
14979 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14980 PyObject *pyobj;
14981
14982 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14983 return pyobj;
14984 }
14985
14986
14987 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14988 PyObject *resultobj;
14989 wxString *arg1 = 0 ;
14990 wxString *arg2 = 0 ;
14991 bool result;
14992 bool temp1 = false ;
14993 bool temp2 = false ;
14994 PyObject * obj0 = 0 ;
14995 PyObject * obj1 = 0 ;
14996 char *kwnames[] = {
14997 (char *) "mimeType",(char *) "wildcard", NULL
14998 };
14999
15000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15001 {
15002 arg1 = wxString_in_helper(obj0);
15003 if (arg1 == NULL) SWIG_fail;
15004 temp1 = true;
15005 }
15006 {
15007 arg2 = wxString_in_helper(obj1);
15008 if (arg2 == NULL) SWIG_fail;
15009 temp2 = true;
15010 }
15011 {
15012 PyThreadState* __tstate = wxPyBeginAllowThreads();
15013 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15014
15015 wxPyEndAllowThreads(__tstate);
15016 if (PyErr_Occurred()) SWIG_fail;
15017 }
15018 {
15019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15020 }
15021 {
15022 if (temp1)
15023 delete arg1;
15024 }
15025 {
15026 if (temp2)
15027 delete arg2;
15028 }
15029 return resultobj;
15030 fail:
15031 {
15032 if (temp1)
15033 delete arg1;
15034 }
15035 {
15036 if (temp2)
15037 delete arg2;
15038 }
15039 return NULL;
15040 }
15041
15042
15043 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15044 PyObject *resultobj;
15045 wxMimeTypesManager *result;
15046 char *kwnames[] = {
15047 NULL
15048 };
15049
15050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15051 {
15052 PyThreadState* __tstate = wxPyBeginAllowThreads();
15053 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15054
15055 wxPyEndAllowThreads(__tstate);
15056 if (PyErr_Occurred()) SWIG_fail;
15057 }
15058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15059 return resultobj;
15060 fail:
15061 return NULL;
15062 }
15063
15064
15065 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15066 PyObject *resultobj;
15067 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15068 int arg2 = (int) wxMAILCAP_ALL ;
15069 wxString const &arg3_defvalue = wxPyEmptyString ;
15070 wxString *arg3 = (wxString *) &arg3_defvalue ;
15071 bool temp3 = false ;
15072 PyObject * obj0 = 0 ;
15073 PyObject * obj1 = 0 ;
15074 PyObject * obj2 = 0 ;
15075 char *kwnames[] = {
15076 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15077 };
15078
15079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15081 if (SWIG_arg_fail(1)) SWIG_fail;
15082 if (obj1) {
15083 {
15084 arg2 = (int)(SWIG_As_int(obj1));
15085 if (SWIG_arg_fail(2)) SWIG_fail;
15086 }
15087 }
15088 if (obj2) {
15089 {
15090 arg3 = wxString_in_helper(obj2);
15091 if (arg3 == NULL) SWIG_fail;
15092 temp3 = true;
15093 }
15094 }
15095 {
15096 PyThreadState* __tstate = wxPyBeginAllowThreads();
15097 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15098
15099 wxPyEndAllowThreads(__tstate);
15100 if (PyErr_Occurred()) SWIG_fail;
15101 }
15102 Py_INCREF(Py_None); resultobj = Py_None;
15103 {
15104 if (temp3)
15105 delete arg3;
15106 }
15107 return resultobj;
15108 fail:
15109 {
15110 if (temp3)
15111 delete arg3;
15112 }
15113 return NULL;
15114 }
15115
15116
15117 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15118 PyObject *resultobj;
15119 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15120 PyObject * obj0 = 0 ;
15121 char *kwnames[] = {
15122 (char *) "self", NULL
15123 };
15124
15125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15127 if (SWIG_arg_fail(1)) SWIG_fail;
15128 {
15129 PyThreadState* __tstate = wxPyBeginAllowThreads();
15130 (arg1)->ClearData();
15131
15132 wxPyEndAllowThreads(__tstate);
15133 if (PyErr_Occurred()) SWIG_fail;
15134 }
15135 Py_INCREF(Py_None); resultobj = Py_None;
15136 return resultobj;
15137 fail:
15138 return NULL;
15139 }
15140
15141
15142 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15143 PyObject *resultobj;
15144 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15145 wxString *arg2 = 0 ;
15146 wxFileType *result;
15147 bool temp2 = false ;
15148 PyObject * obj0 = 0 ;
15149 PyObject * obj1 = 0 ;
15150 char *kwnames[] = {
15151 (char *) "self",(char *) "ext", NULL
15152 };
15153
15154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15156 if (SWIG_arg_fail(1)) SWIG_fail;
15157 {
15158 arg2 = wxString_in_helper(obj1);
15159 if (arg2 == NULL) SWIG_fail;
15160 temp2 = true;
15161 }
15162 {
15163 PyThreadState* __tstate = wxPyBeginAllowThreads();
15164 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15165
15166 wxPyEndAllowThreads(__tstate);
15167 if (PyErr_Occurred()) SWIG_fail;
15168 }
15169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15170 {
15171 if (temp2)
15172 delete arg2;
15173 }
15174 return resultobj;
15175 fail:
15176 {
15177 if (temp2)
15178 delete arg2;
15179 }
15180 return NULL;
15181 }
15182
15183
15184 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15185 PyObject *resultobj;
15186 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15187 wxString *arg2 = 0 ;
15188 wxFileType *result;
15189 bool temp2 = false ;
15190 PyObject * obj0 = 0 ;
15191 PyObject * obj1 = 0 ;
15192 char *kwnames[] = {
15193 (char *) "self",(char *) "mimeType", NULL
15194 };
15195
15196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15198 if (SWIG_arg_fail(1)) SWIG_fail;
15199 {
15200 arg2 = wxString_in_helper(obj1);
15201 if (arg2 == NULL) SWIG_fail;
15202 temp2 = true;
15203 }
15204 {
15205 PyThreadState* __tstate = wxPyBeginAllowThreads();
15206 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15207
15208 wxPyEndAllowThreads(__tstate);
15209 if (PyErr_Occurred()) SWIG_fail;
15210 }
15211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15212 {
15213 if (temp2)
15214 delete arg2;
15215 }
15216 return resultobj;
15217 fail:
15218 {
15219 if (temp2)
15220 delete arg2;
15221 }
15222 return NULL;
15223 }
15224
15225
15226 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15227 PyObject *resultobj;
15228 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15229 wxString *arg2 = 0 ;
15230 bool arg3 = (bool) false ;
15231 bool result;
15232 bool temp2 = false ;
15233 PyObject * obj0 = 0 ;
15234 PyObject * obj1 = 0 ;
15235 PyObject * obj2 = 0 ;
15236 char *kwnames[] = {
15237 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15238 };
15239
15240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15242 if (SWIG_arg_fail(1)) SWIG_fail;
15243 {
15244 arg2 = wxString_in_helper(obj1);
15245 if (arg2 == NULL) SWIG_fail;
15246 temp2 = true;
15247 }
15248 if (obj2) {
15249 {
15250 arg3 = (bool)(SWIG_As_bool(obj2));
15251 if (SWIG_arg_fail(3)) SWIG_fail;
15252 }
15253 }
15254 {
15255 PyThreadState* __tstate = wxPyBeginAllowThreads();
15256 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15257
15258 wxPyEndAllowThreads(__tstate);
15259 if (PyErr_Occurred()) SWIG_fail;
15260 }
15261 {
15262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15263 }
15264 {
15265 if (temp2)
15266 delete arg2;
15267 }
15268 return resultobj;
15269 fail:
15270 {
15271 if (temp2)
15272 delete arg2;
15273 }
15274 return NULL;
15275 }
15276
15277
15278 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15279 PyObject *resultobj;
15280 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15281 wxString *arg2 = 0 ;
15282 bool result;
15283 bool temp2 = false ;
15284 PyObject * obj0 = 0 ;
15285 PyObject * obj1 = 0 ;
15286 char *kwnames[] = {
15287 (char *) "self",(char *) "filename", NULL
15288 };
15289
15290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15292 if (SWIG_arg_fail(1)) SWIG_fail;
15293 {
15294 arg2 = wxString_in_helper(obj1);
15295 if (arg2 == NULL) SWIG_fail;
15296 temp2 = true;
15297 }
15298 {
15299 PyThreadState* __tstate = wxPyBeginAllowThreads();
15300 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15301
15302 wxPyEndAllowThreads(__tstate);
15303 if (PyErr_Occurred()) SWIG_fail;
15304 }
15305 {
15306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15307 }
15308 {
15309 if (temp2)
15310 delete arg2;
15311 }
15312 return resultobj;
15313 fail:
15314 {
15315 if (temp2)
15316 delete arg2;
15317 }
15318 return NULL;
15319 }
15320
15321
15322 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15323 PyObject *resultobj;
15324 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15325 PyObject *result;
15326 PyObject * obj0 = 0 ;
15327 char *kwnames[] = {
15328 (char *) "self", NULL
15329 };
15330
15331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15333 if (SWIG_arg_fail(1)) SWIG_fail;
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15337
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 resultobj = result;
15342 return resultobj;
15343 fail:
15344 return NULL;
15345 }
15346
15347
15348 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15349 PyObject *resultobj;
15350 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15351 wxFileTypeInfo *arg2 = 0 ;
15352 PyObject * obj0 = 0 ;
15353 PyObject * obj1 = 0 ;
15354 char *kwnames[] = {
15355 (char *) "self",(char *) "ft", NULL
15356 };
15357
15358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15360 if (SWIG_arg_fail(1)) SWIG_fail;
15361 {
15362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15363 if (SWIG_arg_fail(2)) SWIG_fail;
15364 if (arg2 == NULL) {
15365 SWIG_null_ref("wxFileTypeInfo");
15366 }
15367 if (SWIG_arg_fail(2)) SWIG_fail;
15368 }
15369 {
15370 PyThreadState* __tstate = wxPyBeginAllowThreads();
15371 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15372
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 Py_INCREF(Py_None); resultobj = Py_None;
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15384 PyObject *resultobj;
15385 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15386 wxFileTypeInfo *arg2 = 0 ;
15387 wxFileType *result;
15388 PyObject * obj0 = 0 ;
15389 PyObject * obj1 = 0 ;
15390 char *kwnames[] = {
15391 (char *) "self",(char *) "ftInfo", NULL
15392 };
15393
15394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15396 if (SWIG_arg_fail(1)) SWIG_fail;
15397 {
15398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15399 if (SWIG_arg_fail(2)) SWIG_fail;
15400 if (arg2 == NULL) {
15401 SWIG_null_ref("wxFileTypeInfo");
15402 }
15403 if (SWIG_arg_fail(2)) SWIG_fail;
15404 }
15405 {
15406 PyThreadState* __tstate = wxPyBeginAllowThreads();
15407 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15408
15409 wxPyEndAllowThreads(__tstate);
15410 if (PyErr_Occurred()) SWIG_fail;
15411 }
15412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15413 return resultobj;
15414 fail:
15415 return NULL;
15416 }
15417
15418
15419 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15420 PyObject *resultobj;
15421 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15422 wxFileType *arg2 = (wxFileType *) 0 ;
15423 bool result;
15424 PyObject * obj0 = 0 ;
15425 PyObject * obj1 = 0 ;
15426 char *kwnames[] = {
15427 (char *) "self",(char *) "ft", NULL
15428 };
15429
15430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15432 if (SWIG_arg_fail(1)) SWIG_fail;
15433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15434 if (SWIG_arg_fail(2)) SWIG_fail;
15435 {
15436 PyThreadState* __tstate = wxPyBeginAllowThreads();
15437 result = (bool)(arg1)->Unassociate(arg2);
15438
15439 wxPyEndAllowThreads(__tstate);
15440 if (PyErr_Occurred()) SWIG_fail;
15441 }
15442 {
15443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15444 }
15445 return resultobj;
15446 fail:
15447 return NULL;
15448 }
15449
15450
15451 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15452 PyObject *resultobj;
15453 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15454 PyObject * obj0 = 0 ;
15455 char *kwnames[] = {
15456 (char *) "self", NULL
15457 };
15458
15459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15461 if (SWIG_arg_fail(1)) SWIG_fail;
15462 {
15463 PyThreadState* __tstate = wxPyBeginAllowThreads();
15464 delete arg1;
15465
15466 wxPyEndAllowThreads(__tstate);
15467 if (PyErr_Occurred()) SWIG_fail;
15468 }
15469 Py_INCREF(Py_None); resultobj = Py_None;
15470 return resultobj;
15471 fail:
15472 return NULL;
15473 }
15474
15475
15476 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15477 PyObject *obj;
15478 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15479 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15480 Py_INCREF(obj);
15481 return Py_BuildValue((char *)"");
15482 }
15483 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15484 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15485 return 1;
15486 }
15487
15488
15489 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15490 PyObject *pyobj;
15491
15492 {
15493 #if wxUSE_UNICODE
15494 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15495 #else
15496 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15497 #endif
15498 }
15499 return pyobj;
15500 }
15501
15502
15503 static int _wrap_ART_MENU_set(PyObject *) {
15504 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15505 return 1;
15506 }
15507
15508
15509 static PyObject *_wrap_ART_MENU_get(void) {
15510 PyObject *pyobj;
15511
15512 {
15513 #if wxUSE_UNICODE
15514 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15515 #else
15516 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15517 #endif
15518 }
15519 return pyobj;
15520 }
15521
15522
15523 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15524 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15525 return 1;
15526 }
15527
15528
15529 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15530 PyObject *pyobj;
15531
15532 {
15533 #if wxUSE_UNICODE
15534 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15535 #else
15536 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15537 #endif
15538 }
15539 return pyobj;
15540 }
15541
15542
15543 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15544 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15545 return 1;
15546 }
15547
15548
15549 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15550 PyObject *pyobj;
15551
15552 {
15553 #if wxUSE_UNICODE
15554 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15555 #else
15556 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15557 #endif
15558 }
15559 return pyobj;
15560 }
15561
15562
15563 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15564 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15565 return 1;
15566 }
15567
15568
15569 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15570 PyObject *pyobj;
15571
15572 {
15573 #if wxUSE_UNICODE
15574 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15575 #else
15576 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15577 #endif
15578 }
15579 return pyobj;
15580 }
15581
15582
15583 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15584 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15585 return 1;
15586 }
15587
15588
15589 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15590 PyObject *pyobj;
15591
15592 {
15593 #if wxUSE_UNICODE
15594 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15595 #else
15596 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15597 #endif
15598 }
15599 return pyobj;
15600 }
15601
15602
15603 static int _wrap_ART_BUTTON_set(PyObject *) {
15604 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15605 return 1;
15606 }
15607
15608
15609 static PyObject *_wrap_ART_BUTTON_get(void) {
15610 PyObject *pyobj;
15611
15612 {
15613 #if wxUSE_UNICODE
15614 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15615 #else
15616 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15617 #endif
15618 }
15619 return pyobj;
15620 }
15621
15622
15623 static int _wrap_ART_OTHER_set(PyObject *) {
15624 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15625 return 1;
15626 }
15627
15628
15629 static PyObject *_wrap_ART_OTHER_get(void) {
15630 PyObject *pyobj;
15631
15632 {
15633 #if wxUSE_UNICODE
15634 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15635 #else
15636 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15637 #endif
15638 }
15639 return pyobj;
15640 }
15641
15642
15643 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15644 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15645 return 1;
15646 }
15647
15648
15649 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15650 PyObject *pyobj;
15651
15652 {
15653 #if wxUSE_UNICODE
15654 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15655 #else
15656 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15657 #endif
15658 }
15659 return pyobj;
15660 }
15661
15662
15663 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15664 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15665 return 1;
15666 }
15667
15668
15669 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15670 PyObject *pyobj;
15671
15672 {
15673 #if wxUSE_UNICODE
15674 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15675 #else
15676 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15677 #endif
15678 }
15679 return pyobj;
15680 }
15681
15682
15683 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15684 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15685 return 1;
15686 }
15687
15688
15689 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15690 PyObject *pyobj;
15691
15692 {
15693 #if wxUSE_UNICODE
15694 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15695 #else
15696 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15697 #endif
15698 }
15699 return pyobj;
15700 }
15701
15702
15703 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15704 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15705 return 1;
15706 }
15707
15708
15709 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15710 PyObject *pyobj;
15711
15712 {
15713 #if wxUSE_UNICODE
15714 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15715 #else
15716 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15717 #endif
15718 }
15719 return pyobj;
15720 }
15721
15722
15723 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15724 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15725 return 1;
15726 }
15727
15728
15729 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15730 PyObject *pyobj;
15731
15732 {
15733 #if wxUSE_UNICODE
15734 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15735 #else
15736 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15737 #endif
15738 }
15739 return pyobj;
15740 }
15741
15742
15743 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15744 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15745 return 1;
15746 }
15747
15748
15749 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15750 PyObject *pyobj;
15751
15752 {
15753 #if wxUSE_UNICODE
15754 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15755 #else
15756 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15757 #endif
15758 }
15759 return pyobj;
15760 }
15761
15762
15763 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15764 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15765 return 1;
15766 }
15767
15768
15769 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15770 PyObject *pyobj;
15771
15772 {
15773 #if wxUSE_UNICODE
15774 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15775 #else
15776 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15777 #endif
15778 }
15779 return pyobj;
15780 }
15781
15782
15783 static int _wrap_ART_GO_BACK_set(PyObject *) {
15784 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15785 return 1;
15786 }
15787
15788
15789 static PyObject *_wrap_ART_GO_BACK_get(void) {
15790 PyObject *pyobj;
15791
15792 {
15793 #if wxUSE_UNICODE
15794 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15795 #else
15796 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15797 #endif
15798 }
15799 return pyobj;
15800 }
15801
15802
15803 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15804 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15805 return 1;
15806 }
15807
15808
15809 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15810 PyObject *pyobj;
15811
15812 {
15813 #if wxUSE_UNICODE
15814 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15815 #else
15816 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15817 #endif
15818 }
15819 return pyobj;
15820 }
15821
15822
15823 static int _wrap_ART_GO_UP_set(PyObject *) {
15824 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15825 return 1;
15826 }
15827
15828
15829 static PyObject *_wrap_ART_GO_UP_get(void) {
15830 PyObject *pyobj;
15831
15832 {
15833 #if wxUSE_UNICODE
15834 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15835 #else
15836 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15837 #endif
15838 }
15839 return pyobj;
15840 }
15841
15842
15843 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15844 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15845 return 1;
15846 }
15847
15848
15849 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15850 PyObject *pyobj;
15851
15852 {
15853 #if wxUSE_UNICODE
15854 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15855 #else
15856 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15857 #endif
15858 }
15859 return pyobj;
15860 }
15861
15862
15863 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15864 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15865 return 1;
15866 }
15867
15868
15869 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15870 PyObject *pyobj;
15871
15872 {
15873 #if wxUSE_UNICODE
15874 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15875 #else
15876 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15877 #endif
15878 }
15879 return pyobj;
15880 }
15881
15882
15883 static int _wrap_ART_GO_HOME_set(PyObject *) {
15884 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15885 return 1;
15886 }
15887
15888
15889 static PyObject *_wrap_ART_GO_HOME_get(void) {
15890 PyObject *pyobj;
15891
15892 {
15893 #if wxUSE_UNICODE
15894 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15895 #else
15896 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15897 #endif
15898 }
15899 return pyobj;
15900 }
15901
15902
15903 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15904 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15905 return 1;
15906 }
15907
15908
15909 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15910 PyObject *pyobj;
15911
15912 {
15913 #if wxUSE_UNICODE
15914 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15915 #else
15916 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15917 #endif
15918 }
15919 return pyobj;
15920 }
15921
15922
15923 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15924 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15925 return 1;
15926 }
15927
15928
15929 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15930 PyObject *pyobj;
15931
15932 {
15933 #if wxUSE_UNICODE
15934 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15935 #else
15936 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15937 #endif
15938 }
15939 return pyobj;
15940 }
15941
15942
15943 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15944 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15945 return 1;
15946 }
15947
15948
15949 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15950 PyObject *pyobj;
15951
15952 {
15953 #if wxUSE_UNICODE
15954 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15955 #else
15956 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15957 #endif
15958 }
15959 return pyobj;
15960 }
15961
15962
15963 static int _wrap_ART_PRINT_set(PyObject *) {
15964 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15965 return 1;
15966 }
15967
15968
15969 static PyObject *_wrap_ART_PRINT_get(void) {
15970 PyObject *pyobj;
15971
15972 {
15973 #if wxUSE_UNICODE
15974 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15975 #else
15976 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15977 #endif
15978 }
15979 return pyobj;
15980 }
15981
15982
15983 static int _wrap_ART_HELP_set(PyObject *) {
15984 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15985 return 1;
15986 }
15987
15988
15989 static PyObject *_wrap_ART_HELP_get(void) {
15990 PyObject *pyobj;
15991
15992 {
15993 #if wxUSE_UNICODE
15994 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15995 #else
15996 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15997 #endif
15998 }
15999 return pyobj;
16000 }
16001
16002
16003 static int _wrap_ART_TIP_set(PyObject *) {
16004 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16005 return 1;
16006 }
16007
16008
16009 static PyObject *_wrap_ART_TIP_get(void) {
16010 PyObject *pyobj;
16011
16012 {
16013 #if wxUSE_UNICODE
16014 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16015 #else
16016 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16017 #endif
16018 }
16019 return pyobj;
16020 }
16021
16022
16023 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16024 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16025 return 1;
16026 }
16027
16028
16029 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16030 PyObject *pyobj;
16031
16032 {
16033 #if wxUSE_UNICODE
16034 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16035 #else
16036 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16037 #endif
16038 }
16039 return pyobj;
16040 }
16041
16042
16043 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16044 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16045 return 1;
16046 }
16047
16048
16049 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16050 PyObject *pyobj;
16051
16052 {
16053 #if wxUSE_UNICODE
16054 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16055 #else
16056 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16057 #endif
16058 }
16059 return pyobj;
16060 }
16061
16062
16063 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16064 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16065 return 1;
16066 }
16067
16068
16069 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16070 PyObject *pyobj;
16071
16072 {
16073 #if wxUSE_UNICODE
16074 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16075 #else
16076 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16077 #endif
16078 }
16079 return pyobj;
16080 }
16081
16082
16083 static int _wrap_ART_HARDDISK_set(PyObject *) {
16084 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16085 return 1;
16086 }
16087
16088
16089 static PyObject *_wrap_ART_HARDDISK_get(void) {
16090 PyObject *pyobj;
16091
16092 {
16093 #if wxUSE_UNICODE
16094 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16095 #else
16096 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16097 #endif
16098 }
16099 return pyobj;
16100 }
16101
16102
16103 static int _wrap_ART_FLOPPY_set(PyObject *) {
16104 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16105 return 1;
16106 }
16107
16108
16109 static PyObject *_wrap_ART_FLOPPY_get(void) {
16110 PyObject *pyobj;
16111
16112 {
16113 #if wxUSE_UNICODE
16114 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16115 #else
16116 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16117 #endif
16118 }
16119 return pyobj;
16120 }
16121
16122
16123 static int _wrap_ART_CDROM_set(PyObject *) {
16124 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16125 return 1;
16126 }
16127
16128
16129 static PyObject *_wrap_ART_CDROM_get(void) {
16130 PyObject *pyobj;
16131
16132 {
16133 #if wxUSE_UNICODE
16134 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16135 #else
16136 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16137 #endif
16138 }
16139 return pyobj;
16140 }
16141
16142
16143 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16144 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16145 return 1;
16146 }
16147
16148
16149 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16150 PyObject *pyobj;
16151
16152 {
16153 #if wxUSE_UNICODE
16154 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16155 #else
16156 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16157 #endif
16158 }
16159 return pyobj;
16160 }
16161
16162
16163 static int _wrap_ART_FOLDER_set(PyObject *) {
16164 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16165 return 1;
16166 }
16167
16168
16169 static PyObject *_wrap_ART_FOLDER_get(void) {
16170 PyObject *pyobj;
16171
16172 {
16173 #if wxUSE_UNICODE
16174 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16175 #else
16176 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16177 #endif
16178 }
16179 return pyobj;
16180 }
16181
16182
16183 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16184 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16185 return 1;
16186 }
16187
16188
16189 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16190 PyObject *pyobj;
16191
16192 {
16193 #if wxUSE_UNICODE
16194 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16195 #else
16196 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16197 #endif
16198 }
16199 return pyobj;
16200 }
16201
16202
16203 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16204 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16205 return 1;
16206 }
16207
16208
16209 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16210 PyObject *pyobj;
16211
16212 {
16213 #if wxUSE_UNICODE
16214 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16215 #else
16216 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16217 #endif
16218 }
16219 return pyobj;
16220 }
16221
16222
16223 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16224 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16225 return 1;
16226 }
16227
16228
16229 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16230 PyObject *pyobj;
16231
16232 {
16233 #if wxUSE_UNICODE
16234 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16235 #else
16236 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16237 #endif
16238 }
16239 return pyobj;
16240 }
16241
16242
16243 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16244 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16245 return 1;
16246 }
16247
16248
16249 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16250 PyObject *pyobj;
16251
16252 {
16253 #if wxUSE_UNICODE
16254 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16255 #else
16256 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16257 #endif
16258 }
16259 return pyobj;
16260 }
16261
16262
16263 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16264 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16265 return 1;
16266 }
16267
16268
16269 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16270 PyObject *pyobj;
16271
16272 {
16273 #if wxUSE_UNICODE
16274 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16275 #else
16276 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16277 #endif
16278 }
16279 return pyobj;
16280 }
16281
16282
16283 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16284 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16285 return 1;
16286 }
16287
16288
16289 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16290 PyObject *pyobj;
16291
16292 {
16293 #if wxUSE_UNICODE
16294 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16295 #else
16296 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16297 #endif
16298 }
16299 return pyobj;
16300 }
16301
16302
16303 static int _wrap_ART_ERROR_set(PyObject *) {
16304 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16305 return 1;
16306 }
16307
16308
16309 static PyObject *_wrap_ART_ERROR_get(void) {
16310 PyObject *pyobj;
16311
16312 {
16313 #if wxUSE_UNICODE
16314 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16315 #else
16316 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16317 #endif
16318 }
16319 return pyobj;
16320 }
16321
16322
16323 static int _wrap_ART_QUESTION_set(PyObject *) {
16324 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16325 return 1;
16326 }
16327
16328
16329 static PyObject *_wrap_ART_QUESTION_get(void) {
16330 PyObject *pyobj;
16331
16332 {
16333 #if wxUSE_UNICODE
16334 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16335 #else
16336 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16337 #endif
16338 }
16339 return pyobj;
16340 }
16341
16342
16343 static int _wrap_ART_WARNING_set(PyObject *) {
16344 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16345 return 1;
16346 }
16347
16348
16349 static PyObject *_wrap_ART_WARNING_get(void) {
16350 PyObject *pyobj;
16351
16352 {
16353 #if wxUSE_UNICODE
16354 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16355 #else
16356 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16357 #endif
16358 }
16359 return pyobj;
16360 }
16361
16362
16363 static int _wrap_ART_INFORMATION_set(PyObject *) {
16364 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16365 return 1;
16366 }
16367
16368
16369 static PyObject *_wrap_ART_INFORMATION_get(void) {
16370 PyObject *pyobj;
16371
16372 {
16373 #if wxUSE_UNICODE
16374 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16375 #else
16376 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16377 #endif
16378 }
16379 return pyobj;
16380 }
16381
16382
16383 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16384 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16385 return 1;
16386 }
16387
16388
16389 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16390 PyObject *pyobj;
16391
16392 {
16393 #if wxUSE_UNICODE
16394 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16395 #else
16396 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16397 #endif
16398 }
16399 return pyobj;
16400 }
16401
16402
16403 static int _wrap_ART_COPY_set(PyObject *) {
16404 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16405 return 1;
16406 }
16407
16408
16409 static PyObject *_wrap_ART_COPY_get(void) {
16410 PyObject *pyobj;
16411
16412 {
16413 #if wxUSE_UNICODE
16414 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16415 #else
16416 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16417 #endif
16418 }
16419 return pyobj;
16420 }
16421
16422
16423 static int _wrap_ART_CUT_set(PyObject *) {
16424 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16425 return 1;
16426 }
16427
16428
16429 static PyObject *_wrap_ART_CUT_get(void) {
16430 PyObject *pyobj;
16431
16432 {
16433 #if wxUSE_UNICODE
16434 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16435 #else
16436 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16437 #endif
16438 }
16439 return pyobj;
16440 }
16441
16442
16443 static int _wrap_ART_PASTE_set(PyObject *) {
16444 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16445 return 1;
16446 }
16447
16448
16449 static PyObject *_wrap_ART_PASTE_get(void) {
16450 PyObject *pyobj;
16451
16452 {
16453 #if wxUSE_UNICODE
16454 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16455 #else
16456 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16457 #endif
16458 }
16459 return pyobj;
16460 }
16461
16462
16463 static int _wrap_ART_DELETE_set(PyObject *) {
16464 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16465 return 1;
16466 }
16467
16468
16469 static PyObject *_wrap_ART_DELETE_get(void) {
16470 PyObject *pyobj;
16471
16472 {
16473 #if wxUSE_UNICODE
16474 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16475 #else
16476 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16477 #endif
16478 }
16479 return pyobj;
16480 }
16481
16482
16483 static int _wrap_ART_NEW_set(PyObject *) {
16484 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW is read-only.");
16485 return 1;
16486 }
16487
16488
16489 static PyObject *_wrap_ART_NEW_get(void) {
16490 PyObject *pyobj;
16491
16492 {
16493 #if wxUSE_UNICODE
16494 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
16495 #else
16496 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
16497 #endif
16498 }
16499 return pyobj;
16500 }
16501
16502
16503 static int _wrap_ART_UNDO_set(PyObject *) {
16504 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16505 return 1;
16506 }
16507
16508
16509 static PyObject *_wrap_ART_UNDO_get(void) {
16510 PyObject *pyobj;
16511
16512 {
16513 #if wxUSE_UNICODE
16514 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16515 #else
16516 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16517 #endif
16518 }
16519 return pyobj;
16520 }
16521
16522
16523 static int _wrap_ART_REDO_set(PyObject *) {
16524 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16525 return 1;
16526 }
16527
16528
16529 static PyObject *_wrap_ART_REDO_get(void) {
16530 PyObject *pyobj;
16531
16532 {
16533 #if wxUSE_UNICODE
16534 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16535 #else
16536 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16537 #endif
16538 }
16539 return pyobj;
16540 }
16541
16542
16543 static int _wrap_ART_QUIT_set(PyObject *) {
16544 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16545 return 1;
16546 }
16547
16548
16549 static PyObject *_wrap_ART_QUIT_get(void) {
16550 PyObject *pyobj;
16551
16552 {
16553 #if wxUSE_UNICODE
16554 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16555 #else
16556 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16557 #endif
16558 }
16559 return pyobj;
16560 }
16561
16562
16563 static int _wrap_ART_FIND_set(PyObject *) {
16564 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16565 return 1;
16566 }
16567
16568
16569 static PyObject *_wrap_ART_FIND_get(void) {
16570 PyObject *pyobj;
16571
16572 {
16573 #if wxUSE_UNICODE
16574 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16575 #else
16576 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16577 #endif
16578 }
16579 return pyobj;
16580 }
16581
16582
16583 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16584 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16585 return 1;
16586 }
16587
16588
16589 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16590 PyObject *pyobj;
16591
16592 {
16593 #if wxUSE_UNICODE
16594 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16595 #else
16596 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16597 #endif
16598 }
16599 return pyobj;
16600 }
16601
16602
16603 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16604 PyObject *resultobj;
16605 wxPyArtProvider *result;
16606 char *kwnames[] = {
16607 NULL
16608 };
16609
16610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16611 {
16612 if (!wxPyCheckForApp()) SWIG_fail;
16613 PyThreadState* __tstate = wxPyBeginAllowThreads();
16614 result = (wxPyArtProvider *)new wxPyArtProvider();
16615
16616 wxPyEndAllowThreads(__tstate);
16617 if (PyErr_Occurred()) SWIG_fail;
16618 }
16619 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16620 return resultobj;
16621 fail:
16622 return NULL;
16623 }
16624
16625
16626 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16627 PyObject *resultobj;
16628 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16629 PyObject *arg2 = (PyObject *) 0 ;
16630 PyObject *arg3 = (PyObject *) 0 ;
16631 PyObject * obj0 = 0 ;
16632 PyObject * obj1 = 0 ;
16633 PyObject * obj2 = 0 ;
16634 char *kwnames[] = {
16635 (char *) "self",(char *) "self",(char *) "_class", NULL
16636 };
16637
16638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16640 if (SWIG_arg_fail(1)) SWIG_fail;
16641 arg2 = obj1;
16642 arg3 = obj2;
16643 {
16644 PyThreadState* __tstate = wxPyBeginAllowThreads();
16645 (arg1)->_setCallbackInfo(arg2,arg3);
16646
16647 wxPyEndAllowThreads(__tstate);
16648 if (PyErr_Occurred()) SWIG_fail;
16649 }
16650 Py_INCREF(Py_None); resultobj = Py_None;
16651 return resultobj;
16652 fail:
16653 return NULL;
16654 }
16655
16656
16657 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16658 PyObject *resultobj;
16659 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16660 PyObject * obj0 = 0 ;
16661 char *kwnames[] = {
16662 (char *) "provider", NULL
16663 };
16664
16665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16667 if (SWIG_arg_fail(1)) SWIG_fail;
16668 {
16669 PyThreadState* __tstate = wxPyBeginAllowThreads();
16670 wxPyArtProvider::PushProvider(arg1);
16671
16672 wxPyEndAllowThreads(__tstate);
16673 if (PyErr_Occurred()) SWIG_fail;
16674 }
16675 Py_INCREF(Py_None); resultobj = Py_None;
16676 return resultobj;
16677 fail:
16678 return NULL;
16679 }
16680
16681
16682 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16683 PyObject *resultobj;
16684 bool result;
16685 char *kwnames[] = {
16686 NULL
16687 };
16688
16689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16690 {
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 result = (bool)wxPyArtProvider::PopProvider();
16693
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 {
16698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16699 }
16700 return resultobj;
16701 fail:
16702 return NULL;
16703 }
16704
16705
16706 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16707 PyObject *resultobj;
16708 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16709 bool result;
16710 PyObject * obj0 = 0 ;
16711 char *kwnames[] = {
16712 (char *) "provider", NULL
16713 };
16714
16715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16717 if (SWIG_arg_fail(1)) SWIG_fail;
16718 {
16719 PyThreadState* __tstate = wxPyBeginAllowThreads();
16720 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16721
16722 wxPyEndAllowThreads(__tstate);
16723 if (PyErr_Occurred()) SWIG_fail;
16724 }
16725 {
16726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16727 }
16728 return resultobj;
16729 fail:
16730 return NULL;
16731 }
16732
16733
16734 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16735 PyObject *resultobj;
16736 wxString *arg1 = 0 ;
16737 wxString const &arg2_defvalue = wxPyART_OTHER ;
16738 wxString *arg2 = (wxString *) &arg2_defvalue ;
16739 wxSize const &arg3_defvalue = wxDefaultSize ;
16740 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16741 wxBitmap result;
16742 bool temp1 = false ;
16743 bool temp2 = false ;
16744 wxSize temp3 ;
16745 PyObject * obj0 = 0 ;
16746 PyObject * obj1 = 0 ;
16747 PyObject * obj2 = 0 ;
16748 char *kwnames[] = {
16749 (char *) "id",(char *) "client",(char *) "size", NULL
16750 };
16751
16752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16753 {
16754 arg1 = wxString_in_helper(obj0);
16755 if (arg1 == NULL) SWIG_fail;
16756 temp1 = true;
16757 }
16758 if (obj1) {
16759 {
16760 arg2 = wxString_in_helper(obj1);
16761 if (arg2 == NULL) SWIG_fail;
16762 temp2 = true;
16763 }
16764 }
16765 if (obj2) {
16766 {
16767 arg3 = &temp3;
16768 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16769 }
16770 }
16771 {
16772 if (!wxPyCheckForApp()) SWIG_fail;
16773 PyThreadState* __tstate = wxPyBeginAllowThreads();
16774 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16775
16776 wxPyEndAllowThreads(__tstate);
16777 if (PyErr_Occurred()) SWIG_fail;
16778 }
16779 {
16780 wxBitmap * resultptr;
16781 resultptr = new wxBitmap((wxBitmap &)(result));
16782 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16783 }
16784 {
16785 if (temp1)
16786 delete arg1;
16787 }
16788 {
16789 if (temp2)
16790 delete arg2;
16791 }
16792 return resultobj;
16793 fail:
16794 {
16795 if (temp1)
16796 delete arg1;
16797 }
16798 {
16799 if (temp2)
16800 delete arg2;
16801 }
16802 return NULL;
16803 }
16804
16805
16806 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16807 PyObject *resultobj;
16808 wxString *arg1 = 0 ;
16809 wxString const &arg2_defvalue = wxPyART_OTHER ;
16810 wxString *arg2 = (wxString *) &arg2_defvalue ;
16811 wxSize const &arg3_defvalue = wxDefaultSize ;
16812 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16813 wxIcon result;
16814 bool temp1 = false ;
16815 bool temp2 = false ;
16816 wxSize temp3 ;
16817 PyObject * obj0 = 0 ;
16818 PyObject * obj1 = 0 ;
16819 PyObject * obj2 = 0 ;
16820 char *kwnames[] = {
16821 (char *) "id",(char *) "client",(char *) "size", NULL
16822 };
16823
16824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16825 {
16826 arg1 = wxString_in_helper(obj0);
16827 if (arg1 == NULL) SWIG_fail;
16828 temp1 = true;
16829 }
16830 if (obj1) {
16831 {
16832 arg2 = wxString_in_helper(obj1);
16833 if (arg2 == NULL) SWIG_fail;
16834 temp2 = true;
16835 }
16836 }
16837 if (obj2) {
16838 {
16839 arg3 = &temp3;
16840 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16841 }
16842 }
16843 {
16844 if (!wxPyCheckForApp()) SWIG_fail;
16845 PyThreadState* __tstate = wxPyBeginAllowThreads();
16846 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16847
16848 wxPyEndAllowThreads(__tstate);
16849 if (PyErr_Occurred()) SWIG_fail;
16850 }
16851 {
16852 wxIcon * resultptr;
16853 resultptr = new wxIcon((wxIcon &)(result));
16854 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16855 }
16856 {
16857 if (temp1)
16858 delete arg1;
16859 }
16860 {
16861 if (temp2)
16862 delete arg2;
16863 }
16864 return resultobj;
16865 fail:
16866 {
16867 if (temp1)
16868 delete arg1;
16869 }
16870 {
16871 if (temp2)
16872 delete arg2;
16873 }
16874 return NULL;
16875 }
16876
16877
16878 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16879 PyObject *resultobj;
16880 wxString *arg1 = 0 ;
16881 bool arg2 = (bool) false ;
16882 wxSize result;
16883 bool temp1 = false ;
16884 PyObject * obj0 = 0 ;
16885 PyObject * obj1 = 0 ;
16886 char *kwnames[] = {
16887 (char *) "client",(char *) "platform_dependent", NULL
16888 };
16889
16890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16891 {
16892 arg1 = wxString_in_helper(obj0);
16893 if (arg1 == NULL) SWIG_fail;
16894 temp1 = true;
16895 }
16896 if (obj1) {
16897 {
16898 arg2 = (bool)(SWIG_As_bool(obj1));
16899 if (SWIG_arg_fail(2)) SWIG_fail;
16900 }
16901 }
16902 {
16903 PyThreadState* __tstate = wxPyBeginAllowThreads();
16904 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16905
16906 wxPyEndAllowThreads(__tstate);
16907 if (PyErr_Occurred()) SWIG_fail;
16908 }
16909 {
16910 wxSize * resultptr;
16911 resultptr = new wxSize((wxSize &)(result));
16912 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16913 }
16914 {
16915 if (temp1)
16916 delete arg1;
16917 }
16918 return resultobj;
16919 fail:
16920 {
16921 if (temp1)
16922 delete arg1;
16923 }
16924 return NULL;
16925 }
16926
16927
16928 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16929 PyObject *resultobj;
16930 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16931 PyObject * obj0 = 0 ;
16932 char *kwnames[] = {
16933 (char *) "self", NULL
16934 };
16935
16936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16938 if (SWIG_arg_fail(1)) SWIG_fail;
16939 {
16940 PyThreadState* __tstate = wxPyBeginAllowThreads();
16941 wxPyArtProvider_Destroy(arg1);
16942
16943 wxPyEndAllowThreads(__tstate);
16944 if (PyErr_Occurred()) SWIG_fail;
16945 }
16946 Py_INCREF(Py_None); resultobj = Py_None;
16947 return resultobj;
16948 fail:
16949 return NULL;
16950 }
16951
16952
16953 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16954 PyObject *obj;
16955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16956 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16957 Py_INCREF(obj);
16958 return Py_BuildValue((char *)"");
16959 }
16960 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16961 PyObject *resultobj;
16962 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16963 PyObject * obj0 = 0 ;
16964 char *kwnames[] = {
16965 (char *) "self", NULL
16966 };
16967
16968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16970 if (SWIG_arg_fail(1)) SWIG_fail;
16971 {
16972 PyThreadState* __tstate = wxPyBeginAllowThreads();
16973 delete arg1;
16974
16975 wxPyEndAllowThreads(__tstate);
16976 if (PyErr_Occurred()) SWIG_fail;
16977 }
16978 Py_INCREF(Py_None); resultobj = Py_None;
16979 return resultobj;
16980 fail:
16981 return NULL;
16982 }
16983
16984
16985 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16986 PyObject *resultobj;
16987 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16988 wxConfigBase *result;
16989 PyObject * obj0 = 0 ;
16990 char *kwnames[] = {
16991 (char *) "config", NULL
16992 };
16993
16994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
16996 if (SWIG_arg_fail(1)) SWIG_fail;
16997 {
16998 PyThreadState* __tstate = wxPyBeginAllowThreads();
16999 result = (wxConfigBase *)wxConfigBase::Set(arg1);
17000
17001 wxPyEndAllowThreads(__tstate);
17002 if (PyErr_Occurred()) SWIG_fail;
17003 }
17004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17005 return resultobj;
17006 fail:
17007 return NULL;
17008 }
17009
17010
17011 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
17012 PyObject *resultobj;
17013 bool arg1 = (bool) true ;
17014 wxConfigBase *result;
17015 PyObject * obj0 = 0 ;
17016 char *kwnames[] = {
17017 (char *) "createOnDemand", NULL
17018 };
17019
17020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
17021 if (obj0) {
17022 {
17023 arg1 = (bool)(SWIG_As_bool(obj0));
17024 if (SWIG_arg_fail(1)) SWIG_fail;
17025 }
17026 }
17027 {
17028 PyThreadState* __tstate = wxPyBeginAllowThreads();
17029 result = (wxConfigBase *)wxConfigBase::Get(arg1);
17030
17031 wxPyEndAllowThreads(__tstate);
17032 if (PyErr_Occurred()) SWIG_fail;
17033 }
17034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17035 return resultobj;
17036 fail:
17037 return NULL;
17038 }
17039
17040
17041 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17042 PyObject *resultobj;
17043 wxConfigBase *result;
17044 char *kwnames[] = {
17045 NULL
17046 };
17047
17048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17049 {
17050 PyThreadState* __tstate = wxPyBeginAllowThreads();
17051 result = (wxConfigBase *)wxConfigBase::Create();
17052
17053 wxPyEndAllowThreads(__tstate);
17054 if (PyErr_Occurred()) SWIG_fail;
17055 }
17056 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17057 return resultobj;
17058 fail:
17059 return NULL;
17060 }
17061
17062
17063 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17064 PyObject *resultobj;
17065 char *kwnames[] = {
17066 NULL
17067 };
17068
17069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17070 {
17071 PyThreadState* __tstate = wxPyBeginAllowThreads();
17072 wxConfigBase::DontCreateOnDemand();
17073
17074 wxPyEndAllowThreads(__tstate);
17075 if (PyErr_Occurred()) SWIG_fail;
17076 }
17077 Py_INCREF(Py_None); resultobj = Py_None;
17078 return resultobj;
17079 fail:
17080 return NULL;
17081 }
17082
17083
17084 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17085 PyObject *resultobj;
17086 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17087 wxString *arg2 = 0 ;
17088 bool temp2 = false ;
17089 PyObject * obj0 = 0 ;
17090 PyObject * obj1 = 0 ;
17091 char *kwnames[] = {
17092 (char *) "self",(char *) "path", NULL
17093 };
17094
17095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17097 if (SWIG_arg_fail(1)) SWIG_fail;
17098 {
17099 arg2 = wxString_in_helper(obj1);
17100 if (arg2 == NULL) SWIG_fail;
17101 temp2 = true;
17102 }
17103 {
17104 PyThreadState* __tstate = wxPyBeginAllowThreads();
17105 (arg1)->SetPath((wxString const &)*arg2);
17106
17107 wxPyEndAllowThreads(__tstate);
17108 if (PyErr_Occurred()) SWIG_fail;
17109 }
17110 Py_INCREF(Py_None); resultobj = Py_None;
17111 {
17112 if (temp2)
17113 delete arg2;
17114 }
17115 return resultobj;
17116 fail:
17117 {
17118 if (temp2)
17119 delete arg2;
17120 }
17121 return NULL;
17122 }
17123
17124
17125 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17126 PyObject *resultobj;
17127 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17128 wxString *result;
17129 PyObject * obj0 = 0 ;
17130 char *kwnames[] = {
17131 (char *) "self", NULL
17132 };
17133
17134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17136 if (SWIG_arg_fail(1)) SWIG_fail;
17137 {
17138 PyThreadState* __tstate = wxPyBeginAllowThreads();
17139 {
17140 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17141 result = (wxString *) &_result_ref;
17142 }
17143
17144 wxPyEndAllowThreads(__tstate);
17145 if (PyErr_Occurred()) SWIG_fail;
17146 }
17147 {
17148 #if wxUSE_UNICODE
17149 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17150 #else
17151 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17152 #endif
17153 }
17154 return resultobj;
17155 fail:
17156 return NULL;
17157 }
17158
17159
17160 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17161 PyObject *resultobj;
17162 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17163 PyObject *result;
17164 PyObject * obj0 = 0 ;
17165 char *kwnames[] = {
17166 (char *) "self", NULL
17167 };
17168
17169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17171 if (SWIG_arg_fail(1)) SWIG_fail;
17172 {
17173 PyThreadState* __tstate = wxPyBeginAllowThreads();
17174 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17175
17176 wxPyEndAllowThreads(__tstate);
17177 if (PyErr_Occurred()) SWIG_fail;
17178 }
17179 resultobj = result;
17180 return resultobj;
17181 fail:
17182 return NULL;
17183 }
17184
17185
17186 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17187 PyObject *resultobj;
17188 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17189 long arg2 ;
17190 PyObject *result;
17191 PyObject * obj0 = 0 ;
17192 PyObject * obj1 = 0 ;
17193 char *kwnames[] = {
17194 (char *) "self",(char *) "index", NULL
17195 };
17196
17197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17199 if (SWIG_arg_fail(1)) SWIG_fail;
17200 {
17201 arg2 = (long)(SWIG_As_long(obj1));
17202 if (SWIG_arg_fail(2)) SWIG_fail;
17203 }
17204 {
17205 PyThreadState* __tstate = wxPyBeginAllowThreads();
17206 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17207
17208 wxPyEndAllowThreads(__tstate);
17209 if (PyErr_Occurred()) SWIG_fail;
17210 }
17211 resultobj = result;
17212 return resultobj;
17213 fail:
17214 return NULL;
17215 }
17216
17217
17218 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17219 PyObject *resultobj;
17220 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17221 PyObject *result;
17222 PyObject * obj0 = 0 ;
17223 char *kwnames[] = {
17224 (char *) "self", NULL
17225 };
17226
17227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17229 if (SWIG_arg_fail(1)) SWIG_fail;
17230 {
17231 PyThreadState* __tstate = wxPyBeginAllowThreads();
17232 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17233
17234 wxPyEndAllowThreads(__tstate);
17235 if (PyErr_Occurred()) SWIG_fail;
17236 }
17237 resultobj = result;
17238 return resultobj;
17239 fail:
17240 return NULL;
17241 }
17242
17243
17244 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17245 PyObject *resultobj;
17246 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17247 long arg2 ;
17248 PyObject *result;
17249 PyObject * obj0 = 0 ;
17250 PyObject * obj1 = 0 ;
17251 char *kwnames[] = {
17252 (char *) "self",(char *) "index", NULL
17253 };
17254
17255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17257 if (SWIG_arg_fail(1)) SWIG_fail;
17258 {
17259 arg2 = (long)(SWIG_As_long(obj1));
17260 if (SWIG_arg_fail(2)) SWIG_fail;
17261 }
17262 {
17263 PyThreadState* __tstate = wxPyBeginAllowThreads();
17264 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17265
17266 wxPyEndAllowThreads(__tstate);
17267 if (PyErr_Occurred()) SWIG_fail;
17268 }
17269 resultobj = result;
17270 return resultobj;
17271 fail:
17272 return NULL;
17273 }
17274
17275
17276 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17277 PyObject *resultobj;
17278 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17279 bool arg2 = (bool) false ;
17280 size_t result;
17281 PyObject * obj0 = 0 ;
17282 PyObject * obj1 = 0 ;
17283 char *kwnames[] = {
17284 (char *) "self",(char *) "recursive", NULL
17285 };
17286
17287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17289 if (SWIG_arg_fail(1)) SWIG_fail;
17290 if (obj1) {
17291 {
17292 arg2 = (bool)(SWIG_As_bool(obj1));
17293 if (SWIG_arg_fail(2)) SWIG_fail;
17294 }
17295 }
17296 {
17297 PyThreadState* __tstate = wxPyBeginAllowThreads();
17298 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17299
17300 wxPyEndAllowThreads(__tstate);
17301 if (PyErr_Occurred()) SWIG_fail;
17302 }
17303 {
17304 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17305 }
17306 return resultobj;
17307 fail:
17308 return NULL;
17309 }
17310
17311
17312 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17313 PyObject *resultobj;
17314 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17315 bool arg2 = (bool) false ;
17316 size_t result;
17317 PyObject * obj0 = 0 ;
17318 PyObject * obj1 = 0 ;
17319 char *kwnames[] = {
17320 (char *) "self",(char *) "recursive", NULL
17321 };
17322
17323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17325 if (SWIG_arg_fail(1)) SWIG_fail;
17326 if (obj1) {
17327 {
17328 arg2 = (bool)(SWIG_As_bool(obj1));
17329 if (SWIG_arg_fail(2)) SWIG_fail;
17330 }
17331 }
17332 {
17333 PyThreadState* __tstate = wxPyBeginAllowThreads();
17334 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17335
17336 wxPyEndAllowThreads(__tstate);
17337 if (PyErr_Occurred()) SWIG_fail;
17338 }
17339 {
17340 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17341 }
17342 return resultobj;
17343 fail:
17344 return NULL;
17345 }
17346
17347
17348 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17349 PyObject *resultobj;
17350 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17351 wxString *arg2 = 0 ;
17352 bool result;
17353 bool temp2 = false ;
17354 PyObject * obj0 = 0 ;
17355 PyObject * obj1 = 0 ;
17356 char *kwnames[] = {
17357 (char *) "self",(char *) "name", NULL
17358 };
17359
17360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17362 if (SWIG_arg_fail(1)) SWIG_fail;
17363 {
17364 arg2 = wxString_in_helper(obj1);
17365 if (arg2 == NULL) SWIG_fail;
17366 temp2 = true;
17367 }
17368 {
17369 PyThreadState* __tstate = wxPyBeginAllowThreads();
17370 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17371
17372 wxPyEndAllowThreads(__tstate);
17373 if (PyErr_Occurred()) SWIG_fail;
17374 }
17375 {
17376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17377 }
17378 {
17379 if (temp2)
17380 delete arg2;
17381 }
17382 return resultobj;
17383 fail:
17384 {
17385 if (temp2)
17386 delete arg2;
17387 }
17388 return NULL;
17389 }
17390
17391
17392 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17393 PyObject *resultobj;
17394 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17395 wxString *arg2 = 0 ;
17396 bool result;
17397 bool temp2 = false ;
17398 PyObject * obj0 = 0 ;
17399 PyObject * obj1 = 0 ;
17400 char *kwnames[] = {
17401 (char *) "self",(char *) "name", NULL
17402 };
17403
17404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17406 if (SWIG_arg_fail(1)) SWIG_fail;
17407 {
17408 arg2 = wxString_in_helper(obj1);
17409 if (arg2 == NULL) SWIG_fail;
17410 temp2 = true;
17411 }
17412 {
17413 PyThreadState* __tstate = wxPyBeginAllowThreads();
17414 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17415
17416 wxPyEndAllowThreads(__tstate);
17417 if (PyErr_Occurred()) SWIG_fail;
17418 }
17419 {
17420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17421 }
17422 {
17423 if (temp2)
17424 delete arg2;
17425 }
17426 return resultobj;
17427 fail:
17428 {
17429 if (temp2)
17430 delete arg2;
17431 }
17432 return NULL;
17433 }
17434
17435
17436 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17437 PyObject *resultobj;
17438 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17439 wxString *arg2 = 0 ;
17440 bool result;
17441 bool temp2 = false ;
17442 PyObject * obj0 = 0 ;
17443 PyObject * obj1 = 0 ;
17444 char *kwnames[] = {
17445 (char *) "self",(char *) "name", NULL
17446 };
17447
17448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17450 if (SWIG_arg_fail(1)) SWIG_fail;
17451 {
17452 arg2 = wxString_in_helper(obj1);
17453 if (arg2 == NULL) SWIG_fail;
17454 temp2 = true;
17455 }
17456 {
17457 PyThreadState* __tstate = wxPyBeginAllowThreads();
17458 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17459
17460 wxPyEndAllowThreads(__tstate);
17461 if (PyErr_Occurred()) SWIG_fail;
17462 }
17463 {
17464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17465 }
17466 {
17467 if (temp2)
17468 delete arg2;
17469 }
17470 return resultobj;
17471 fail:
17472 {
17473 if (temp2)
17474 delete arg2;
17475 }
17476 return NULL;
17477 }
17478
17479
17480 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17481 PyObject *resultobj;
17482 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17483 wxString *arg2 = 0 ;
17484 wxConfigBase::EntryType result;
17485 bool temp2 = false ;
17486 PyObject * obj0 = 0 ;
17487 PyObject * obj1 = 0 ;
17488 char *kwnames[] = {
17489 (char *) "self",(char *) "name", NULL
17490 };
17491
17492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17494 if (SWIG_arg_fail(1)) SWIG_fail;
17495 {
17496 arg2 = wxString_in_helper(obj1);
17497 if (arg2 == NULL) SWIG_fail;
17498 temp2 = true;
17499 }
17500 {
17501 PyThreadState* __tstate = wxPyBeginAllowThreads();
17502 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17503
17504 wxPyEndAllowThreads(__tstate);
17505 if (PyErr_Occurred()) SWIG_fail;
17506 }
17507 resultobj = SWIG_From_int((result));
17508 {
17509 if (temp2)
17510 delete arg2;
17511 }
17512 return resultobj;
17513 fail:
17514 {
17515 if (temp2)
17516 delete arg2;
17517 }
17518 return NULL;
17519 }
17520
17521
17522 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17523 PyObject *resultobj;
17524 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17525 wxString *arg2 = 0 ;
17526 wxString const &arg3_defvalue = wxPyEmptyString ;
17527 wxString *arg3 = (wxString *) &arg3_defvalue ;
17528 wxString result;
17529 bool temp2 = false ;
17530 bool temp3 = false ;
17531 PyObject * obj0 = 0 ;
17532 PyObject * obj1 = 0 ;
17533 PyObject * obj2 = 0 ;
17534 char *kwnames[] = {
17535 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17536 };
17537
17538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17540 if (SWIG_arg_fail(1)) SWIG_fail;
17541 {
17542 arg2 = wxString_in_helper(obj1);
17543 if (arg2 == NULL) SWIG_fail;
17544 temp2 = true;
17545 }
17546 if (obj2) {
17547 {
17548 arg3 = wxString_in_helper(obj2);
17549 if (arg3 == NULL) SWIG_fail;
17550 temp3 = true;
17551 }
17552 }
17553 {
17554 PyThreadState* __tstate = wxPyBeginAllowThreads();
17555 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17556
17557 wxPyEndAllowThreads(__tstate);
17558 if (PyErr_Occurred()) SWIG_fail;
17559 }
17560 {
17561 #if wxUSE_UNICODE
17562 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17563 #else
17564 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17565 #endif
17566 }
17567 {
17568 if (temp2)
17569 delete arg2;
17570 }
17571 {
17572 if (temp3)
17573 delete arg3;
17574 }
17575 return resultobj;
17576 fail:
17577 {
17578 if (temp2)
17579 delete arg2;
17580 }
17581 {
17582 if (temp3)
17583 delete arg3;
17584 }
17585 return NULL;
17586 }
17587
17588
17589 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17590 PyObject *resultobj;
17591 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17592 wxString *arg2 = 0 ;
17593 long arg3 = (long) 0 ;
17594 long result;
17595 bool temp2 = false ;
17596 PyObject * obj0 = 0 ;
17597 PyObject * obj1 = 0 ;
17598 PyObject * obj2 = 0 ;
17599 char *kwnames[] = {
17600 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17601 };
17602
17603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17605 if (SWIG_arg_fail(1)) SWIG_fail;
17606 {
17607 arg2 = wxString_in_helper(obj1);
17608 if (arg2 == NULL) SWIG_fail;
17609 temp2 = true;
17610 }
17611 if (obj2) {
17612 {
17613 arg3 = (long)(SWIG_As_long(obj2));
17614 if (SWIG_arg_fail(3)) SWIG_fail;
17615 }
17616 }
17617 {
17618 PyThreadState* __tstate = wxPyBeginAllowThreads();
17619 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17620
17621 wxPyEndAllowThreads(__tstate);
17622 if (PyErr_Occurred()) SWIG_fail;
17623 }
17624 {
17625 resultobj = SWIG_From_long((long)(result));
17626 }
17627 {
17628 if (temp2)
17629 delete arg2;
17630 }
17631 return resultobj;
17632 fail:
17633 {
17634 if (temp2)
17635 delete arg2;
17636 }
17637 return NULL;
17638 }
17639
17640
17641 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17642 PyObject *resultobj;
17643 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17644 wxString *arg2 = 0 ;
17645 double arg3 = (double) 0.0 ;
17646 double result;
17647 bool temp2 = false ;
17648 PyObject * obj0 = 0 ;
17649 PyObject * obj1 = 0 ;
17650 PyObject * obj2 = 0 ;
17651 char *kwnames[] = {
17652 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17653 };
17654
17655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17657 if (SWIG_arg_fail(1)) SWIG_fail;
17658 {
17659 arg2 = wxString_in_helper(obj1);
17660 if (arg2 == NULL) SWIG_fail;
17661 temp2 = true;
17662 }
17663 if (obj2) {
17664 {
17665 arg3 = (double)(SWIG_As_double(obj2));
17666 if (SWIG_arg_fail(3)) SWIG_fail;
17667 }
17668 }
17669 {
17670 PyThreadState* __tstate = wxPyBeginAllowThreads();
17671 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17672
17673 wxPyEndAllowThreads(__tstate);
17674 if (PyErr_Occurred()) SWIG_fail;
17675 }
17676 {
17677 resultobj = SWIG_From_double((double)(result));
17678 }
17679 {
17680 if (temp2)
17681 delete arg2;
17682 }
17683 return resultobj;
17684 fail:
17685 {
17686 if (temp2)
17687 delete arg2;
17688 }
17689 return NULL;
17690 }
17691
17692
17693 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17694 PyObject *resultobj;
17695 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17696 wxString *arg2 = 0 ;
17697 bool arg3 = (bool) false ;
17698 bool result;
17699 bool temp2 = false ;
17700 PyObject * obj0 = 0 ;
17701 PyObject * obj1 = 0 ;
17702 PyObject * obj2 = 0 ;
17703 char *kwnames[] = {
17704 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17705 };
17706
17707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17709 if (SWIG_arg_fail(1)) SWIG_fail;
17710 {
17711 arg2 = wxString_in_helper(obj1);
17712 if (arg2 == NULL) SWIG_fail;
17713 temp2 = true;
17714 }
17715 if (obj2) {
17716 {
17717 arg3 = (bool)(SWIG_As_bool(obj2));
17718 if (SWIG_arg_fail(3)) SWIG_fail;
17719 }
17720 }
17721 {
17722 PyThreadState* __tstate = wxPyBeginAllowThreads();
17723 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17724
17725 wxPyEndAllowThreads(__tstate);
17726 if (PyErr_Occurred()) SWIG_fail;
17727 }
17728 {
17729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17730 }
17731 {
17732 if (temp2)
17733 delete arg2;
17734 }
17735 return resultobj;
17736 fail:
17737 {
17738 if (temp2)
17739 delete arg2;
17740 }
17741 return NULL;
17742 }
17743
17744
17745 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17746 PyObject *resultobj;
17747 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17748 wxString *arg2 = 0 ;
17749 wxString *arg3 = 0 ;
17750 bool result;
17751 bool temp2 = false ;
17752 bool temp3 = false ;
17753 PyObject * obj0 = 0 ;
17754 PyObject * obj1 = 0 ;
17755 PyObject * obj2 = 0 ;
17756 char *kwnames[] = {
17757 (char *) "self",(char *) "key",(char *) "value", NULL
17758 };
17759
17760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17762 if (SWIG_arg_fail(1)) SWIG_fail;
17763 {
17764 arg2 = wxString_in_helper(obj1);
17765 if (arg2 == NULL) SWIG_fail;
17766 temp2 = true;
17767 }
17768 {
17769 arg3 = wxString_in_helper(obj2);
17770 if (arg3 == NULL) SWIG_fail;
17771 temp3 = true;
17772 }
17773 {
17774 PyThreadState* __tstate = wxPyBeginAllowThreads();
17775 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17776
17777 wxPyEndAllowThreads(__tstate);
17778 if (PyErr_Occurred()) SWIG_fail;
17779 }
17780 {
17781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17782 }
17783 {
17784 if (temp2)
17785 delete arg2;
17786 }
17787 {
17788 if (temp3)
17789 delete arg3;
17790 }
17791 return resultobj;
17792 fail:
17793 {
17794 if (temp2)
17795 delete arg2;
17796 }
17797 {
17798 if (temp3)
17799 delete arg3;
17800 }
17801 return NULL;
17802 }
17803
17804
17805 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17806 PyObject *resultobj;
17807 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17808 wxString *arg2 = 0 ;
17809 long arg3 ;
17810 bool result;
17811 bool temp2 = false ;
17812 PyObject * obj0 = 0 ;
17813 PyObject * obj1 = 0 ;
17814 PyObject * obj2 = 0 ;
17815 char *kwnames[] = {
17816 (char *) "self",(char *) "key",(char *) "value", NULL
17817 };
17818
17819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17821 if (SWIG_arg_fail(1)) SWIG_fail;
17822 {
17823 arg2 = wxString_in_helper(obj1);
17824 if (arg2 == NULL) SWIG_fail;
17825 temp2 = true;
17826 }
17827 {
17828 arg3 = (long)(SWIG_As_long(obj2));
17829 if (SWIG_arg_fail(3)) SWIG_fail;
17830 }
17831 {
17832 PyThreadState* __tstate = wxPyBeginAllowThreads();
17833 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17834
17835 wxPyEndAllowThreads(__tstate);
17836 if (PyErr_Occurred()) SWIG_fail;
17837 }
17838 {
17839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17840 }
17841 {
17842 if (temp2)
17843 delete arg2;
17844 }
17845 return resultobj;
17846 fail:
17847 {
17848 if (temp2)
17849 delete arg2;
17850 }
17851 return NULL;
17852 }
17853
17854
17855 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17856 PyObject *resultobj;
17857 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17858 wxString *arg2 = 0 ;
17859 double arg3 ;
17860 bool result;
17861 bool temp2 = false ;
17862 PyObject * obj0 = 0 ;
17863 PyObject * obj1 = 0 ;
17864 PyObject * obj2 = 0 ;
17865 char *kwnames[] = {
17866 (char *) "self",(char *) "key",(char *) "value", NULL
17867 };
17868
17869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17871 if (SWIG_arg_fail(1)) SWIG_fail;
17872 {
17873 arg2 = wxString_in_helper(obj1);
17874 if (arg2 == NULL) SWIG_fail;
17875 temp2 = true;
17876 }
17877 {
17878 arg3 = (double)(SWIG_As_double(obj2));
17879 if (SWIG_arg_fail(3)) SWIG_fail;
17880 }
17881 {
17882 PyThreadState* __tstate = wxPyBeginAllowThreads();
17883 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17884
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 {
17889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17890 }
17891 {
17892 if (temp2)
17893 delete arg2;
17894 }
17895 return resultobj;
17896 fail:
17897 {
17898 if (temp2)
17899 delete arg2;
17900 }
17901 return NULL;
17902 }
17903
17904
17905 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17906 PyObject *resultobj;
17907 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17908 wxString *arg2 = 0 ;
17909 bool arg3 ;
17910 bool result;
17911 bool temp2 = false ;
17912 PyObject * obj0 = 0 ;
17913 PyObject * obj1 = 0 ;
17914 PyObject * obj2 = 0 ;
17915 char *kwnames[] = {
17916 (char *) "self",(char *) "key",(char *) "value", NULL
17917 };
17918
17919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17921 if (SWIG_arg_fail(1)) SWIG_fail;
17922 {
17923 arg2 = wxString_in_helper(obj1);
17924 if (arg2 == NULL) SWIG_fail;
17925 temp2 = true;
17926 }
17927 {
17928 arg3 = (bool)(SWIG_As_bool(obj2));
17929 if (SWIG_arg_fail(3)) SWIG_fail;
17930 }
17931 {
17932 PyThreadState* __tstate = wxPyBeginAllowThreads();
17933 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17934
17935 wxPyEndAllowThreads(__tstate);
17936 if (PyErr_Occurred()) SWIG_fail;
17937 }
17938 {
17939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17940 }
17941 {
17942 if (temp2)
17943 delete arg2;
17944 }
17945 return resultobj;
17946 fail:
17947 {
17948 if (temp2)
17949 delete arg2;
17950 }
17951 return NULL;
17952 }
17953
17954
17955 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17956 PyObject *resultobj;
17957 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17958 bool arg2 = (bool) false ;
17959 bool result;
17960 PyObject * obj0 = 0 ;
17961 PyObject * obj1 = 0 ;
17962 char *kwnames[] = {
17963 (char *) "self",(char *) "currentOnly", NULL
17964 };
17965
17966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17968 if (SWIG_arg_fail(1)) SWIG_fail;
17969 if (obj1) {
17970 {
17971 arg2 = (bool)(SWIG_As_bool(obj1));
17972 if (SWIG_arg_fail(2)) SWIG_fail;
17973 }
17974 }
17975 {
17976 PyThreadState* __tstate = wxPyBeginAllowThreads();
17977 result = (bool)(arg1)->Flush(arg2);
17978
17979 wxPyEndAllowThreads(__tstate);
17980 if (PyErr_Occurred()) SWIG_fail;
17981 }
17982 {
17983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17984 }
17985 return resultobj;
17986 fail:
17987 return NULL;
17988 }
17989
17990
17991 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17992 PyObject *resultobj;
17993 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17994 wxString *arg2 = 0 ;
17995 wxString *arg3 = 0 ;
17996 bool result;
17997 bool temp2 = false ;
17998 bool temp3 = false ;
17999 PyObject * obj0 = 0 ;
18000 PyObject * obj1 = 0 ;
18001 PyObject * obj2 = 0 ;
18002 char *kwnames[] = {
18003 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18004 };
18005
18006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18008 if (SWIG_arg_fail(1)) SWIG_fail;
18009 {
18010 arg2 = wxString_in_helper(obj1);
18011 if (arg2 == NULL) SWIG_fail;
18012 temp2 = true;
18013 }
18014 {
18015 arg3 = wxString_in_helper(obj2);
18016 if (arg3 == NULL) SWIG_fail;
18017 temp3 = true;
18018 }
18019 {
18020 PyThreadState* __tstate = wxPyBeginAllowThreads();
18021 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
18022
18023 wxPyEndAllowThreads(__tstate);
18024 if (PyErr_Occurred()) SWIG_fail;
18025 }
18026 {
18027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18028 }
18029 {
18030 if (temp2)
18031 delete arg2;
18032 }
18033 {
18034 if (temp3)
18035 delete arg3;
18036 }
18037 return resultobj;
18038 fail:
18039 {
18040 if (temp2)
18041 delete arg2;
18042 }
18043 {
18044 if (temp3)
18045 delete arg3;
18046 }
18047 return NULL;
18048 }
18049
18050
18051 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18052 PyObject *resultobj;
18053 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18054 wxString *arg2 = 0 ;
18055 wxString *arg3 = 0 ;
18056 bool result;
18057 bool temp2 = false ;
18058 bool temp3 = false ;
18059 PyObject * obj0 = 0 ;
18060 PyObject * obj1 = 0 ;
18061 PyObject * obj2 = 0 ;
18062 char *kwnames[] = {
18063 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18064 };
18065
18066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18068 if (SWIG_arg_fail(1)) SWIG_fail;
18069 {
18070 arg2 = wxString_in_helper(obj1);
18071 if (arg2 == NULL) SWIG_fail;
18072 temp2 = true;
18073 }
18074 {
18075 arg3 = wxString_in_helper(obj2);
18076 if (arg3 == NULL) SWIG_fail;
18077 temp3 = true;
18078 }
18079 {
18080 PyThreadState* __tstate = wxPyBeginAllowThreads();
18081 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18082
18083 wxPyEndAllowThreads(__tstate);
18084 if (PyErr_Occurred()) SWIG_fail;
18085 }
18086 {
18087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18088 }
18089 {
18090 if (temp2)
18091 delete arg2;
18092 }
18093 {
18094 if (temp3)
18095 delete arg3;
18096 }
18097 return resultobj;
18098 fail:
18099 {
18100 if (temp2)
18101 delete arg2;
18102 }
18103 {
18104 if (temp3)
18105 delete arg3;
18106 }
18107 return NULL;
18108 }
18109
18110
18111 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18112 PyObject *resultobj;
18113 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18114 wxString *arg2 = 0 ;
18115 bool arg3 = (bool) true ;
18116 bool result;
18117 bool temp2 = false ;
18118 PyObject * obj0 = 0 ;
18119 PyObject * obj1 = 0 ;
18120 PyObject * obj2 = 0 ;
18121 char *kwnames[] = {
18122 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18123 };
18124
18125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18127 if (SWIG_arg_fail(1)) SWIG_fail;
18128 {
18129 arg2 = wxString_in_helper(obj1);
18130 if (arg2 == NULL) SWIG_fail;
18131 temp2 = true;
18132 }
18133 if (obj2) {
18134 {
18135 arg3 = (bool)(SWIG_As_bool(obj2));
18136 if (SWIG_arg_fail(3)) SWIG_fail;
18137 }
18138 }
18139 {
18140 PyThreadState* __tstate = wxPyBeginAllowThreads();
18141 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18142
18143 wxPyEndAllowThreads(__tstate);
18144 if (PyErr_Occurred()) SWIG_fail;
18145 }
18146 {
18147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18148 }
18149 {
18150 if (temp2)
18151 delete arg2;
18152 }
18153 return resultobj;
18154 fail:
18155 {
18156 if (temp2)
18157 delete arg2;
18158 }
18159 return NULL;
18160 }
18161
18162
18163 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18164 PyObject *resultobj;
18165 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18166 wxString *arg2 = 0 ;
18167 bool result;
18168 bool temp2 = false ;
18169 PyObject * obj0 = 0 ;
18170 PyObject * obj1 = 0 ;
18171 char *kwnames[] = {
18172 (char *) "self",(char *) "key", NULL
18173 };
18174
18175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18177 if (SWIG_arg_fail(1)) SWIG_fail;
18178 {
18179 arg2 = wxString_in_helper(obj1);
18180 if (arg2 == NULL) SWIG_fail;
18181 temp2 = true;
18182 }
18183 {
18184 PyThreadState* __tstate = wxPyBeginAllowThreads();
18185 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18186
18187 wxPyEndAllowThreads(__tstate);
18188 if (PyErr_Occurred()) SWIG_fail;
18189 }
18190 {
18191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18192 }
18193 {
18194 if (temp2)
18195 delete arg2;
18196 }
18197 return resultobj;
18198 fail:
18199 {
18200 if (temp2)
18201 delete arg2;
18202 }
18203 return NULL;
18204 }
18205
18206
18207 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18208 PyObject *resultobj;
18209 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18210 bool result;
18211 PyObject * obj0 = 0 ;
18212 char *kwnames[] = {
18213 (char *) "self", NULL
18214 };
18215
18216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18218 if (SWIG_arg_fail(1)) SWIG_fail;
18219 {
18220 PyThreadState* __tstate = wxPyBeginAllowThreads();
18221 result = (bool)(arg1)->DeleteAll();
18222
18223 wxPyEndAllowThreads(__tstate);
18224 if (PyErr_Occurred()) SWIG_fail;
18225 }
18226 {
18227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18228 }
18229 return resultobj;
18230 fail:
18231 return NULL;
18232 }
18233
18234
18235 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18236 PyObject *resultobj;
18237 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18238 bool arg2 = (bool) true ;
18239 PyObject * obj0 = 0 ;
18240 PyObject * obj1 = 0 ;
18241 char *kwnames[] = {
18242 (char *) "self",(char *) "doIt", NULL
18243 };
18244
18245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18247 if (SWIG_arg_fail(1)) SWIG_fail;
18248 if (obj1) {
18249 {
18250 arg2 = (bool)(SWIG_As_bool(obj1));
18251 if (SWIG_arg_fail(2)) SWIG_fail;
18252 }
18253 }
18254 {
18255 PyThreadState* __tstate = wxPyBeginAllowThreads();
18256 (arg1)->SetExpandEnvVars(arg2);
18257
18258 wxPyEndAllowThreads(__tstate);
18259 if (PyErr_Occurred()) SWIG_fail;
18260 }
18261 Py_INCREF(Py_None); resultobj = Py_None;
18262 return resultobj;
18263 fail:
18264 return NULL;
18265 }
18266
18267
18268 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18269 PyObject *resultobj;
18270 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18271 bool result;
18272 PyObject * obj0 = 0 ;
18273 char *kwnames[] = {
18274 (char *) "self", NULL
18275 };
18276
18277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18279 if (SWIG_arg_fail(1)) SWIG_fail;
18280 {
18281 PyThreadState* __tstate = wxPyBeginAllowThreads();
18282 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18283
18284 wxPyEndAllowThreads(__tstate);
18285 if (PyErr_Occurred()) SWIG_fail;
18286 }
18287 {
18288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18289 }
18290 return resultobj;
18291 fail:
18292 return NULL;
18293 }
18294
18295
18296 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18297 PyObject *resultobj;
18298 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18299 bool arg2 = (bool) true ;
18300 PyObject * obj0 = 0 ;
18301 PyObject * obj1 = 0 ;
18302 char *kwnames[] = {
18303 (char *) "self",(char *) "doIt", NULL
18304 };
18305
18306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18308 if (SWIG_arg_fail(1)) SWIG_fail;
18309 if (obj1) {
18310 {
18311 arg2 = (bool)(SWIG_As_bool(obj1));
18312 if (SWIG_arg_fail(2)) SWIG_fail;
18313 }
18314 }
18315 {
18316 PyThreadState* __tstate = wxPyBeginAllowThreads();
18317 (arg1)->SetRecordDefaults(arg2);
18318
18319 wxPyEndAllowThreads(__tstate);
18320 if (PyErr_Occurred()) SWIG_fail;
18321 }
18322 Py_INCREF(Py_None); resultobj = Py_None;
18323 return resultobj;
18324 fail:
18325 return NULL;
18326 }
18327
18328
18329 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18330 PyObject *resultobj;
18331 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18332 bool result;
18333 PyObject * obj0 = 0 ;
18334 char *kwnames[] = {
18335 (char *) "self", NULL
18336 };
18337
18338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18340 if (SWIG_arg_fail(1)) SWIG_fail;
18341 {
18342 PyThreadState* __tstate = wxPyBeginAllowThreads();
18343 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18344
18345 wxPyEndAllowThreads(__tstate);
18346 if (PyErr_Occurred()) SWIG_fail;
18347 }
18348 {
18349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18350 }
18351 return resultobj;
18352 fail:
18353 return NULL;
18354 }
18355
18356
18357 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18358 PyObject *resultobj;
18359 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18360 wxString *arg2 = 0 ;
18361 wxString result;
18362 bool temp2 = false ;
18363 PyObject * obj0 = 0 ;
18364 PyObject * obj1 = 0 ;
18365 char *kwnames[] = {
18366 (char *) "self",(char *) "str", NULL
18367 };
18368
18369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18371 if (SWIG_arg_fail(1)) SWIG_fail;
18372 {
18373 arg2 = wxString_in_helper(obj1);
18374 if (arg2 == NULL) SWIG_fail;
18375 temp2 = true;
18376 }
18377 {
18378 PyThreadState* __tstate = wxPyBeginAllowThreads();
18379 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18380
18381 wxPyEndAllowThreads(__tstate);
18382 if (PyErr_Occurred()) SWIG_fail;
18383 }
18384 {
18385 #if wxUSE_UNICODE
18386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18387 #else
18388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18389 #endif
18390 }
18391 {
18392 if (temp2)
18393 delete arg2;
18394 }
18395 return resultobj;
18396 fail:
18397 {
18398 if (temp2)
18399 delete arg2;
18400 }
18401 return NULL;
18402 }
18403
18404
18405 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18406 PyObject *resultobj;
18407 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18408 wxString result;
18409 PyObject * obj0 = 0 ;
18410 char *kwnames[] = {
18411 (char *) "self", NULL
18412 };
18413
18414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18416 if (SWIG_arg_fail(1)) SWIG_fail;
18417 {
18418 PyThreadState* __tstate = wxPyBeginAllowThreads();
18419 result = ((wxConfigBase const *)arg1)->GetAppName();
18420
18421 wxPyEndAllowThreads(__tstate);
18422 if (PyErr_Occurred()) SWIG_fail;
18423 }
18424 {
18425 #if wxUSE_UNICODE
18426 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18427 #else
18428 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18429 #endif
18430 }
18431 return resultobj;
18432 fail:
18433 return NULL;
18434 }
18435
18436
18437 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18438 PyObject *resultobj;
18439 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18440 wxString result;
18441 PyObject * obj0 = 0 ;
18442 char *kwnames[] = {
18443 (char *) "self", NULL
18444 };
18445
18446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18448 if (SWIG_arg_fail(1)) SWIG_fail;
18449 {
18450 PyThreadState* __tstate = wxPyBeginAllowThreads();
18451 result = ((wxConfigBase const *)arg1)->GetVendorName();
18452
18453 wxPyEndAllowThreads(__tstate);
18454 if (PyErr_Occurred()) SWIG_fail;
18455 }
18456 {
18457 #if wxUSE_UNICODE
18458 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18459 #else
18460 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18461 #endif
18462 }
18463 return resultobj;
18464 fail:
18465 return NULL;
18466 }
18467
18468
18469 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18470 PyObject *resultobj;
18471 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18472 wxString *arg2 = 0 ;
18473 bool temp2 = false ;
18474 PyObject * obj0 = 0 ;
18475 PyObject * obj1 = 0 ;
18476 char *kwnames[] = {
18477 (char *) "self",(char *) "appName", NULL
18478 };
18479
18480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18482 if (SWIG_arg_fail(1)) SWIG_fail;
18483 {
18484 arg2 = wxString_in_helper(obj1);
18485 if (arg2 == NULL) SWIG_fail;
18486 temp2 = true;
18487 }
18488 {
18489 PyThreadState* __tstate = wxPyBeginAllowThreads();
18490 (arg1)->SetAppName((wxString const &)*arg2);
18491
18492 wxPyEndAllowThreads(__tstate);
18493 if (PyErr_Occurred()) SWIG_fail;
18494 }
18495 Py_INCREF(Py_None); resultobj = Py_None;
18496 {
18497 if (temp2)
18498 delete arg2;
18499 }
18500 return resultobj;
18501 fail:
18502 {
18503 if (temp2)
18504 delete arg2;
18505 }
18506 return NULL;
18507 }
18508
18509
18510 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18511 PyObject *resultobj;
18512 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18513 wxString *arg2 = 0 ;
18514 bool temp2 = false ;
18515 PyObject * obj0 = 0 ;
18516 PyObject * obj1 = 0 ;
18517 char *kwnames[] = {
18518 (char *) "self",(char *) "vendorName", NULL
18519 };
18520
18521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18523 if (SWIG_arg_fail(1)) SWIG_fail;
18524 {
18525 arg2 = wxString_in_helper(obj1);
18526 if (arg2 == NULL) SWIG_fail;
18527 temp2 = true;
18528 }
18529 {
18530 PyThreadState* __tstate = wxPyBeginAllowThreads();
18531 (arg1)->SetVendorName((wxString const &)*arg2);
18532
18533 wxPyEndAllowThreads(__tstate);
18534 if (PyErr_Occurred()) SWIG_fail;
18535 }
18536 Py_INCREF(Py_None); resultobj = Py_None;
18537 {
18538 if (temp2)
18539 delete arg2;
18540 }
18541 return resultobj;
18542 fail:
18543 {
18544 if (temp2)
18545 delete arg2;
18546 }
18547 return NULL;
18548 }
18549
18550
18551 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18552 PyObject *resultobj;
18553 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18554 long arg2 ;
18555 PyObject * obj0 = 0 ;
18556 PyObject * obj1 = 0 ;
18557 char *kwnames[] = {
18558 (char *) "self",(char *) "style", NULL
18559 };
18560
18561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18563 if (SWIG_arg_fail(1)) SWIG_fail;
18564 {
18565 arg2 = (long)(SWIG_As_long(obj1));
18566 if (SWIG_arg_fail(2)) SWIG_fail;
18567 }
18568 {
18569 PyThreadState* __tstate = wxPyBeginAllowThreads();
18570 (arg1)->SetStyle(arg2);
18571
18572 wxPyEndAllowThreads(__tstate);
18573 if (PyErr_Occurred()) SWIG_fail;
18574 }
18575 Py_INCREF(Py_None); resultobj = Py_None;
18576 return resultobj;
18577 fail:
18578 return NULL;
18579 }
18580
18581
18582 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18583 PyObject *resultobj;
18584 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18585 long result;
18586 PyObject * obj0 = 0 ;
18587 char *kwnames[] = {
18588 (char *) "self", NULL
18589 };
18590
18591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18593 if (SWIG_arg_fail(1)) SWIG_fail;
18594 {
18595 PyThreadState* __tstate = wxPyBeginAllowThreads();
18596 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18597
18598 wxPyEndAllowThreads(__tstate);
18599 if (PyErr_Occurred()) SWIG_fail;
18600 }
18601 {
18602 resultobj = SWIG_From_long((long)(result));
18603 }
18604 return resultobj;
18605 fail:
18606 return NULL;
18607 }
18608
18609
18610 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18611 PyObject *obj;
18612 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18613 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18614 Py_INCREF(obj);
18615 return Py_BuildValue((char *)"");
18616 }
18617 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18618 PyObject *resultobj;
18619 wxString const &arg1_defvalue = wxPyEmptyString ;
18620 wxString *arg1 = (wxString *) &arg1_defvalue ;
18621 wxString const &arg2_defvalue = wxPyEmptyString ;
18622 wxString *arg2 = (wxString *) &arg2_defvalue ;
18623 wxString const &arg3_defvalue = wxPyEmptyString ;
18624 wxString *arg3 = (wxString *) &arg3_defvalue ;
18625 wxString const &arg4_defvalue = wxPyEmptyString ;
18626 wxString *arg4 = (wxString *) &arg4_defvalue ;
18627 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18628 wxConfig *result;
18629 bool temp1 = false ;
18630 bool temp2 = false ;
18631 bool temp3 = false ;
18632 bool temp4 = false ;
18633 PyObject * obj0 = 0 ;
18634 PyObject * obj1 = 0 ;
18635 PyObject * obj2 = 0 ;
18636 PyObject * obj3 = 0 ;
18637 PyObject * obj4 = 0 ;
18638 char *kwnames[] = {
18639 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18640 };
18641
18642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18643 if (obj0) {
18644 {
18645 arg1 = wxString_in_helper(obj0);
18646 if (arg1 == NULL) SWIG_fail;
18647 temp1 = true;
18648 }
18649 }
18650 if (obj1) {
18651 {
18652 arg2 = wxString_in_helper(obj1);
18653 if (arg2 == NULL) SWIG_fail;
18654 temp2 = true;
18655 }
18656 }
18657 if (obj2) {
18658 {
18659 arg3 = wxString_in_helper(obj2);
18660 if (arg3 == NULL) SWIG_fail;
18661 temp3 = true;
18662 }
18663 }
18664 if (obj3) {
18665 {
18666 arg4 = wxString_in_helper(obj3);
18667 if (arg4 == NULL) SWIG_fail;
18668 temp4 = true;
18669 }
18670 }
18671 if (obj4) {
18672 {
18673 arg5 = (long)(SWIG_As_long(obj4));
18674 if (SWIG_arg_fail(5)) SWIG_fail;
18675 }
18676 }
18677 {
18678 PyThreadState* __tstate = wxPyBeginAllowThreads();
18679 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18680
18681 wxPyEndAllowThreads(__tstate);
18682 if (PyErr_Occurred()) SWIG_fail;
18683 }
18684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18685 {
18686 if (temp1)
18687 delete arg1;
18688 }
18689 {
18690 if (temp2)
18691 delete arg2;
18692 }
18693 {
18694 if (temp3)
18695 delete arg3;
18696 }
18697 {
18698 if (temp4)
18699 delete arg4;
18700 }
18701 return resultobj;
18702 fail:
18703 {
18704 if (temp1)
18705 delete arg1;
18706 }
18707 {
18708 if (temp2)
18709 delete arg2;
18710 }
18711 {
18712 if (temp3)
18713 delete arg3;
18714 }
18715 {
18716 if (temp4)
18717 delete arg4;
18718 }
18719 return NULL;
18720 }
18721
18722
18723 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18724 PyObject *resultobj;
18725 wxConfig *arg1 = (wxConfig *) 0 ;
18726 PyObject * obj0 = 0 ;
18727 char *kwnames[] = {
18728 (char *) "self", NULL
18729 };
18730
18731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18733 if (SWIG_arg_fail(1)) SWIG_fail;
18734 {
18735 PyThreadState* __tstate = wxPyBeginAllowThreads();
18736 delete arg1;
18737
18738 wxPyEndAllowThreads(__tstate);
18739 if (PyErr_Occurred()) SWIG_fail;
18740 }
18741 Py_INCREF(Py_None); resultobj = Py_None;
18742 return resultobj;
18743 fail:
18744 return NULL;
18745 }
18746
18747
18748 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18749 PyObject *obj;
18750 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18751 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18752 Py_INCREF(obj);
18753 return Py_BuildValue((char *)"");
18754 }
18755 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18756 PyObject *resultobj;
18757 wxString const &arg1_defvalue = wxPyEmptyString ;
18758 wxString *arg1 = (wxString *) &arg1_defvalue ;
18759 wxString const &arg2_defvalue = wxPyEmptyString ;
18760 wxString *arg2 = (wxString *) &arg2_defvalue ;
18761 wxString const &arg3_defvalue = wxPyEmptyString ;
18762 wxString *arg3 = (wxString *) &arg3_defvalue ;
18763 wxString const &arg4_defvalue = wxPyEmptyString ;
18764 wxString *arg4 = (wxString *) &arg4_defvalue ;
18765 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18766 wxFileConfig *result;
18767 bool temp1 = false ;
18768 bool temp2 = false ;
18769 bool temp3 = false ;
18770 bool temp4 = false ;
18771 PyObject * obj0 = 0 ;
18772 PyObject * obj1 = 0 ;
18773 PyObject * obj2 = 0 ;
18774 PyObject * obj3 = 0 ;
18775 PyObject * obj4 = 0 ;
18776 char *kwnames[] = {
18777 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18778 };
18779
18780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18781 if (obj0) {
18782 {
18783 arg1 = wxString_in_helper(obj0);
18784 if (arg1 == NULL) SWIG_fail;
18785 temp1 = true;
18786 }
18787 }
18788 if (obj1) {
18789 {
18790 arg2 = wxString_in_helper(obj1);
18791 if (arg2 == NULL) SWIG_fail;
18792 temp2 = true;
18793 }
18794 }
18795 if (obj2) {
18796 {
18797 arg3 = wxString_in_helper(obj2);
18798 if (arg3 == NULL) SWIG_fail;
18799 temp3 = true;
18800 }
18801 }
18802 if (obj3) {
18803 {
18804 arg4 = wxString_in_helper(obj3);
18805 if (arg4 == NULL) SWIG_fail;
18806 temp4 = true;
18807 }
18808 }
18809 if (obj4) {
18810 {
18811 arg5 = (long)(SWIG_As_long(obj4));
18812 if (SWIG_arg_fail(5)) SWIG_fail;
18813 }
18814 }
18815 {
18816 PyThreadState* __tstate = wxPyBeginAllowThreads();
18817 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18818
18819 wxPyEndAllowThreads(__tstate);
18820 if (PyErr_Occurred()) SWIG_fail;
18821 }
18822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18823 {
18824 if (temp1)
18825 delete arg1;
18826 }
18827 {
18828 if (temp2)
18829 delete arg2;
18830 }
18831 {
18832 if (temp3)
18833 delete arg3;
18834 }
18835 {
18836 if (temp4)
18837 delete arg4;
18838 }
18839 return resultobj;
18840 fail:
18841 {
18842 if (temp1)
18843 delete arg1;
18844 }
18845 {
18846 if (temp2)
18847 delete arg2;
18848 }
18849 {
18850 if (temp3)
18851 delete arg3;
18852 }
18853 {
18854 if (temp4)
18855 delete arg4;
18856 }
18857 return NULL;
18858 }
18859
18860
18861 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18862 PyObject *resultobj;
18863 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18864 PyObject * obj0 = 0 ;
18865 char *kwnames[] = {
18866 (char *) "self", NULL
18867 };
18868
18869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18871 if (SWIG_arg_fail(1)) SWIG_fail;
18872 {
18873 PyThreadState* __tstate = wxPyBeginAllowThreads();
18874 delete arg1;
18875
18876 wxPyEndAllowThreads(__tstate);
18877 if (PyErr_Occurred()) SWIG_fail;
18878 }
18879 Py_INCREF(Py_None); resultobj = Py_None;
18880 return resultobj;
18881 fail:
18882 return NULL;
18883 }
18884
18885
18886 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18887 PyObject *obj;
18888 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18889 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18890 Py_INCREF(obj);
18891 return Py_BuildValue((char *)"");
18892 }
18893 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18894 PyObject *resultobj;
18895 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18896 wxString *arg2 = 0 ;
18897 wxConfigPathChanger *result;
18898 bool temp2 = false ;
18899 PyObject * obj0 = 0 ;
18900 PyObject * obj1 = 0 ;
18901 char *kwnames[] = {
18902 (char *) "config",(char *) "entry", NULL
18903 };
18904
18905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18907 if (SWIG_arg_fail(1)) SWIG_fail;
18908 {
18909 arg2 = wxString_in_helper(obj1);
18910 if (arg2 == NULL) SWIG_fail;
18911 temp2 = true;
18912 }
18913 {
18914 PyThreadState* __tstate = wxPyBeginAllowThreads();
18915 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18916
18917 wxPyEndAllowThreads(__tstate);
18918 if (PyErr_Occurred()) SWIG_fail;
18919 }
18920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18921 {
18922 if (temp2)
18923 delete arg2;
18924 }
18925 return resultobj;
18926 fail:
18927 {
18928 if (temp2)
18929 delete arg2;
18930 }
18931 return NULL;
18932 }
18933
18934
18935 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18936 PyObject *resultobj;
18937 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18938 PyObject * obj0 = 0 ;
18939 char *kwnames[] = {
18940 (char *) "self", NULL
18941 };
18942
18943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18945 if (SWIG_arg_fail(1)) SWIG_fail;
18946 {
18947 PyThreadState* __tstate = wxPyBeginAllowThreads();
18948 delete arg1;
18949
18950 wxPyEndAllowThreads(__tstate);
18951 if (PyErr_Occurred()) SWIG_fail;
18952 }
18953 Py_INCREF(Py_None); resultobj = Py_None;
18954 return resultobj;
18955 fail:
18956 return NULL;
18957 }
18958
18959
18960 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18961 PyObject *resultobj;
18962 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18963 wxString *result;
18964 PyObject * obj0 = 0 ;
18965 char *kwnames[] = {
18966 (char *) "self", NULL
18967 };
18968
18969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18971 if (SWIG_arg_fail(1)) SWIG_fail;
18972 {
18973 PyThreadState* __tstate = wxPyBeginAllowThreads();
18974 {
18975 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18976 result = (wxString *) &_result_ref;
18977 }
18978
18979 wxPyEndAllowThreads(__tstate);
18980 if (PyErr_Occurred()) SWIG_fail;
18981 }
18982 {
18983 #if wxUSE_UNICODE
18984 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18985 #else
18986 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18987 #endif
18988 }
18989 return resultobj;
18990 fail:
18991 return NULL;
18992 }
18993
18994
18995 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18996 PyObject *obj;
18997 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18998 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18999 Py_INCREF(obj);
19000 return Py_BuildValue((char *)"");
19001 }
19002 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19003 PyObject *resultobj;
19004 wxString *arg1 = 0 ;
19005 wxString result;
19006 bool temp1 = false ;
19007 PyObject * obj0 = 0 ;
19008 char *kwnames[] = {
19009 (char *) "sz", NULL
19010 };
19011
19012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
19013 {
19014 arg1 = wxString_in_helper(obj0);
19015 if (arg1 == NULL) SWIG_fail;
19016 temp1 = true;
19017 }
19018 {
19019 PyThreadState* __tstate = wxPyBeginAllowThreads();
19020 result = wxExpandEnvVars((wxString const &)*arg1);
19021
19022 wxPyEndAllowThreads(__tstate);
19023 if (PyErr_Occurred()) SWIG_fail;
19024 }
19025 {
19026 #if wxUSE_UNICODE
19027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19028 #else
19029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19030 #endif
19031 }
19032 {
19033 if (temp1)
19034 delete arg1;
19035 }
19036 return resultobj;
19037 fail:
19038 {
19039 if (temp1)
19040 delete arg1;
19041 }
19042 return NULL;
19043 }
19044
19045
19046 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19047 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19048 return 1;
19049 }
19050
19051
19052 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19053 PyObject *pyobj;
19054
19055 {
19056 #if wxUSE_UNICODE
19057 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19058 #else
19059 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19060 #endif
19061 }
19062 return pyobj;
19063 }
19064
19065
19066 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19067 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19068 return 1;
19069 }
19070
19071
19072 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19073 PyObject *pyobj;
19074
19075 {
19076 #if wxUSE_UNICODE
19077 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19078 #else
19079 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19080 #endif
19081 }
19082 return pyobj;
19083 }
19084
19085
19086 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19087 PyObject *resultobj;
19088 wxDateTime::Country arg1 ;
19089 PyObject * obj0 = 0 ;
19090 char *kwnames[] = {
19091 (char *) "country", NULL
19092 };
19093
19094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19095 {
19096 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19097 if (SWIG_arg_fail(1)) SWIG_fail;
19098 }
19099 {
19100 PyThreadState* __tstate = wxPyBeginAllowThreads();
19101 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19102
19103 wxPyEndAllowThreads(__tstate);
19104 if (PyErr_Occurred()) SWIG_fail;
19105 }
19106 Py_INCREF(Py_None); resultobj = Py_None;
19107 return resultobj;
19108 fail:
19109 return NULL;
19110 }
19111
19112
19113 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19114 PyObject *resultobj;
19115 wxDateTime::Country result;
19116 char *kwnames[] = {
19117 NULL
19118 };
19119
19120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19121 {
19122 PyThreadState* __tstate = wxPyBeginAllowThreads();
19123 result = (wxDateTime::Country)wxDateTime::GetCountry();
19124
19125 wxPyEndAllowThreads(__tstate);
19126 if (PyErr_Occurred()) SWIG_fail;
19127 }
19128 resultobj = SWIG_From_int((result));
19129 return resultobj;
19130 fail:
19131 return NULL;
19132 }
19133
19134
19135 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19136 PyObject *resultobj;
19137 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19138 bool result;
19139 PyObject * obj0 = 0 ;
19140 char *kwnames[] = {
19141 (char *) "country", NULL
19142 };
19143
19144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19145 if (obj0) {
19146 {
19147 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19148 if (SWIG_arg_fail(1)) SWIG_fail;
19149 }
19150 }
19151 {
19152 PyThreadState* __tstate = wxPyBeginAllowThreads();
19153 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19154
19155 wxPyEndAllowThreads(__tstate);
19156 if (PyErr_Occurred()) SWIG_fail;
19157 }
19158 {
19159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19160 }
19161 return resultobj;
19162 fail:
19163 return NULL;
19164 }
19165
19166
19167 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19168 PyObject *resultobj;
19169 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19170 int result;
19171 PyObject * obj0 = 0 ;
19172 char *kwnames[] = {
19173 (char *) "cal", NULL
19174 };
19175
19176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19177 if (obj0) {
19178 {
19179 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19180 if (SWIG_arg_fail(1)) SWIG_fail;
19181 }
19182 }
19183 {
19184 PyThreadState* __tstate = wxPyBeginAllowThreads();
19185 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19186
19187 wxPyEndAllowThreads(__tstate);
19188 if (PyErr_Occurred()) SWIG_fail;
19189 }
19190 {
19191 resultobj = SWIG_From_int((int)(result));
19192 }
19193 return resultobj;
19194 fail:
19195 return NULL;
19196 }
19197
19198
19199 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19200 PyObject *resultobj;
19201 int arg1 ;
19202 int result;
19203 PyObject * obj0 = 0 ;
19204 char *kwnames[] = {
19205 (char *) "year", NULL
19206 };
19207
19208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19209 {
19210 arg1 = (int)(SWIG_As_int(obj0));
19211 if (SWIG_arg_fail(1)) SWIG_fail;
19212 }
19213 {
19214 PyThreadState* __tstate = wxPyBeginAllowThreads();
19215 result = (int)wxDateTime::ConvertYearToBC(arg1);
19216
19217 wxPyEndAllowThreads(__tstate);
19218 if (PyErr_Occurred()) SWIG_fail;
19219 }
19220 {
19221 resultobj = SWIG_From_int((int)(result));
19222 }
19223 return resultobj;
19224 fail:
19225 return NULL;
19226 }
19227
19228
19229 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19230 PyObject *resultobj;
19231 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19232 wxDateTime::Month result;
19233 PyObject * obj0 = 0 ;
19234 char *kwnames[] = {
19235 (char *) "cal", NULL
19236 };
19237
19238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19239 if (obj0) {
19240 {
19241 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19242 if (SWIG_arg_fail(1)) SWIG_fail;
19243 }
19244 }
19245 {
19246 PyThreadState* __tstate = wxPyBeginAllowThreads();
19247 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19248
19249 wxPyEndAllowThreads(__tstate);
19250 if (PyErr_Occurred()) SWIG_fail;
19251 }
19252 resultobj = SWIG_From_int((result));
19253 return resultobj;
19254 fail:
19255 return NULL;
19256 }
19257
19258
19259 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19260 PyObject *resultobj;
19261 int arg1 = (int) wxDateTime::Inv_Year ;
19262 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19263 bool result;
19264 PyObject * obj0 = 0 ;
19265 PyObject * obj1 = 0 ;
19266 char *kwnames[] = {
19267 (char *) "year",(char *) "cal", NULL
19268 };
19269
19270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19271 if (obj0) {
19272 {
19273 arg1 = (int)(SWIG_As_int(obj0));
19274 if (SWIG_arg_fail(1)) SWIG_fail;
19275 }
19276 }
19277 if (obj1) {
19278 {
19279 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19280 if (SWIG_arg_fail(2)) SWIG_fail;
19281 }
19282 }
19283 {
19284 PyThreadState* __tstate = wxPyBeginAllowThreads();
19285 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19286
19287 wxPyEndAllowThreads(__tstate);
19288 if (PyErr_Occurred()) SWIG_fail;
19289 }
19290 {
19291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19292 }
19293 return resultobj;
19294 fail:
19295 return NULL;
19296 }
19297
19298
19299 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19300 PyObject *resultobj;
19301 int arg1 = (int) wxDateTime::Inv_Year ;
19302 int result;
19303 PyObject * obj0 = 0 ;
19304 char *kwnames[] = {
19305 (char *) "year", NULL
19306 };
19307
19308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19309 if (obj0) {
19310 {
19311 arg1 = (int)(SWIG_As_int(obj0));
19312 if (SWIG_arg_fail(1)) SWIG_fail;
19313 }
19314 }
19315 {
19316 PyThreadState* __tstate = wxPyBeginAllowThreads();
19317 result = (int)wxDateTime::GetCentury(arg1);
19318
19319 wxPyEndAllowThreads(__tstate);
19320 if (PyErr_Occurred()) SWIG_fail;
19321 }
19322 {
19323 resultobj = SWIG_From_int((int)(result));
19324 }
19325 return resultobj;
19326 fail:
19327 return NULL;
19328 }
19329
19330
19331 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19332 PyObject *resultobj;
19333 int arg1 ;
19334 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19335 int result;
19336 PyObject * obj0 = 0 ;
19337 PyObject * obj1 = 0 ;
19338 char *kwnames[] = {
19339 (char *) "year",(char *) "cal", NULL
19340 };
19341
19342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19343 {
19344 arg1 = (int)(SWIG_As_int(obj0));
19345 if (SWIG_arg_fail(1)) SWIG_fail;
19346 }
19347 if (obj1) {
19348 {
19349 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19350 if (SWIG_arg_fail(2)) SWIG_fail;
19351 }
19352 }
19353 {
19354 PyThreadState* __tstate = wxPyBeginAllowThreads();
19355 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19356
19357 wxPyEndAllowThreads(__tstate);
19358 if (PyErr_Occurred()) SWIG_fail;
19359 }
19360 {
19361 resultobj = SWIG_From_int((int)(result));
19362 }
19363 return resultobj;
19364 fail:
19365 return NULL;
19366 }
19367
19368
19369 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19370 PyObject *resultobj;
19371 wxDateTime::Month arg1 ;
19372 int arg2 = (int) wxDateTime::Inv_Year ;
19373 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19374 int result;
19375 PyObject * obj0 = 0 ;
19376 PyObject * obj1 = 0 ;
19377 PyObject * obj2 = 0 ;
19378 char *kwnames[] = {
19379 (char *) "month",(char *) "year",(char *) "cal", NULL
19380 };
19381
19382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19383 {
19384 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19385 if (SWIG_arg_fail(1)) SWIG_fail;
19386 }
19387 if (obj1) {
19388 {
19389 arg2 = (int)(SWIG_As_int(obj1));
19390 if (SWIG_arg_fail(2)) SWIG_fail;
19391 }
19392 }
19393 if (obj2) {
19394 {
19395 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19396 if (SWIG_arg_fail(3)) SWIG_fail;
19397 }
19398 }
19399 {
19400 PyThreadState* __tstate = wxPyBeginAllowThreads();
19401 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19402
19403 wxPyEndAllowThreads(__tstate);
19404 if (PyErr_Occurred()) SWIG_fail;
19405 }
19406 {
19407 resultobj = SWIG_From_int((int)(result));
19408 }
19409 return resultobj;
19410 fail:
19411 return NULL;
19412 }
19413
19414
19415 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19416 PyObject *resultobj;
19417 wxDateTime::Month arg1 ;
19418 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19419 wxString result;
19420 PyObject * obj0 = 0 ;
19421 PyObject * obj1 = 0 ;
19422 char *kwnames[] = {
19423 (char *) "month",(char *) "flags", NULL
19424 };
19425
19426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19427 {
19428 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19429 if (SWIG_arg_fail(1)) SWIG_fail;
19430 }
19431 if (obj1) {
19432 {
19433 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19434 if (SWIG_arg_fail(2)) SWIG_fail;
19435 }
19436 }
19437 {
19438 PyThreadState* __tstate = wxPyBeginAllowThreads();
19439 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19440
19441 wxPyEndAllowThreads(__tstate);
19442 if (PyErr_Occurred()) SWIG_fail;
19443 }
19444 {
19445 #if wxUSE_UNICODE
19446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19447 #else
19448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19449 #endif
19450 }
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19458 PyObject *resultobj;
19459 wxDateTime::WeekDay arg1 ;
19460 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19461 wxString result;
19462 PyObject * obj0 = 0 ;
19463 PyObject * obj1 = 0 ;
19464 char *kwnames[] = {
19465 (char *) "weekday",(char *) "flags", NULL
19466 };
19467
19468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19469 {
19470 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19471 if (SWIG_arg_fail(1)) SWIG_fail;
19472 }
19473 if (obj1) {
19474 {
19475 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19476 if (SWIG_arg_fail(2)) SWIG_fail;
19477 }
19478 }
19479 {
19480 PyThreadState* __tstate = wxPyBeginAllowThreads();
19481 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19482
19483 wxPyEndAllowThreads(__tstate);
19484 if (PyErr_Occurred()) SWIG_fail;
19485 }
19486 {
19487 #if wxUSE_UNICODE
19488 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19489 #else
19490 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19491 #endif
19492 }
19493 return resultobj;
19494 fail:
19495 return NULL;
19496 }
19497
19498
19499 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19500 PyObject *resultobj;
19501 PyObject *result;
19502 char *kwnames[] = {
19503 NULL
19504 };
19505
19506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19507 {
19508 PyThreadState* __tstate = wxPyBeginAllowThreads();
19509 result = (PyObject *)DateTime_GetAmPmStrings();
19510
19511 wxPyEndAllowThreads(__tstate);
19512 if (PyErr_Occurred()) SWIG_fail;
19513 }
19514 resultobj = result;
19515 return resultobj;
19516 fail:
19517 return NULL;
19518 }
19519
19520
19521 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19522 PyObject *resultobj;
19523 int arg1 = (int) wxDateTime::Inv_Year ;
19524 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19525 bool result;
19526 PyObject * obj0 = 0 ;
19527 PyObject * obj1 = 0 ;
19528 char *kwnames[] = {
19529 (char *) "year",(char *) "country", NULL
19530 };
19531
19532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19533 if (obj0) {
19534 {
19535 arg1 = (int)(SWIG_As_int(obj0));
19536 if (SWIG_arg_fail(1)) SWIG_fail;
19537 }
19538 }
19539 if (obj1) {
19540 {
19541 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19542 if (SWIG_arg_fail(2)) SWIG_fail;
19543 }
19544 }
19545 {
19546 PyThreadState* __tstate = wxPyBeginAllowThreads();
19547 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19548
19549 wxPyEndAllowThreads(__tstate);
19550 if (PyErr_Occurred()) SWIG_fail;
19551 }
19552 {
19553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19554 }
19555 return resultobj;
19556 fail:
19557 return NULL;
19558 }
19559
19560
19561 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19562 PyObject *resultobj;
19563 int arg1 = (int) wxDateTime::Inv_Year ;
19564 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19565 wxDateTime result;
19566 PyObject * obj0 = 0 ;
19567 PyObject * obj1 = 0 ;
19568 char *kwnames[] = {
19569 (char *) "year",(char *) "country", NULL
19570 };
19571
19572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19573 if (obj0) {
19574 {
19575 arg1 = (int)(SWIG_As_int(obj0));
19576 if (SWIG_arg_fail(1)) SWIG_fail;
19577 }
19578 }
19579 if (obj1) {
19580 {
19581 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19582 if (SWIG_arg_fail(2)) SWIG_fail;
19583 }
19584 }
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19588
19589 wxPyEndAllowThreads(__tstate);
19590 if (PyErr_Occurred()) SWIG_fail;
19591 }
19592 {
19593 wxDateTime * resultptr;
19594 resultptr = new wxDateTime((wxDateTime &)(result));
19595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19596 }
19597 return resultobj;
19598 fail:
19599 return NULL;
19600 }
19601
19602
19603 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19604 PyObject *resultobj;
19605 int arg1 = (int) wxDateTime::Inv_Year ;
19606 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19607 wxDateTime result;
19608 PyObject * obj0 = 0 ;
19609 PyObject * obj1 = 0 ;
19610 char *kwnames[] = {
19611 (char *) "year",(char *) "country", NULL
19612 };
19613
19614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19615 if (obj0) {
19616 {
19617 arg1 = (int)(SWIG_As_int(obj0));
19618 if (SWIG_arg_fail(1)) SWIG_fail;
19619 }
19620 }
19621 if (obj1) {
19622 {
19623 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19624 if (SWIG_arg_fail(2)) SWIG_fail;
19625 }
19626 }
19627 {
19628 PyThreadState* __tstate = wxPyBeginAllowThreads();
19629 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19630
19631 wxPyEndAllowThreads(__tstate);
19632 if (PyErr_Occurred()) SWIG_fail;
19633 }
19634 {
19635 wxDateTime * resultptr;
19636 resultptr = new wxDateTime((wxDateTime &)(result));
19637 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19638 }
19639 return resultobj;
19640 fail:
19641 return NULL;
19642 }
19643
19644
19645 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19646 PyObject *resultobj;
19647 wxDateTime result;
19648 char *kwnames[] = {
19649 NULL
19650 };
19651
19652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19653 {
19654 PyThreadState* __tstate = wxPyBeginAllowThreads();
19655 result = wxDateTime::Now();
19656
19657 wxPyEndAllowThreads(__tstate);
19658 if (PyErr_Occurred()) SWIG_fail;
19659 }
19660 {
19661 wxDateTime * resultptr;
19662 resultptr = new wxDateTime((wxDateTime &)(result));
19663 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19664 }
19665 return resultobj;
19666 fail:
19667 return NULL;
19668 }
19669
19670
19671 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19672 PyObject *resultobj;
19673 wxDateTime result;
19674 char *kwnames[] = {
19675 NULL
19676 };
19677
19678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19679 {
19680 PyThreadState* __tstate = wxPyBeginAllowThreads();
19681 result = wxDateTime::UNow();
19682
19683 wxPyEndAllowThreads(__tstate);
19684 if (PyErr_Occurred()) SWIG_fail;
19685 }
19686 {
19687 wxDateTime * resultptr;
19688 resultptr = new wxDateTime((wxDateTime &)(result));
19689 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19690 }
19691 return resultobj;
19692 fail:
19693 return NULL;
19694 }
19695
19696
19697 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19698 PyObject *resultobj;
19699 wxDateTime result;
19700 char *kwnames[] = {
19701 NULL
19702 };
19703
19704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19705 {
19706 PyThreadState* __tstate = wxPyBeginAllowThreads();
19707 result = wxDateTime::Today();
19708
19709 wxPyEndAllowThreads(__tstate);
19710 if (PyErr_Occurred()) SWIG_fail;
19711 }
19712 {
19713 wxDateTime * resultptr;
19714 resultptr = new wxDateTime((wxDateTime &)(result));
19715 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19716 }
19717 return resultobj;
19718 fail:
19719 return NULL;
19720 }
19721
19722
19723 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19724 PyObject *resultobj;
19725 wxDateTime *result;
19726 char *kwnames[] = {
19727 NULL
19728 };
19729
19730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19731 {
19732 PyThreadState* __tstate = wxPyBeginAllowThreads();
19733 result = (wxDateTime *)new wxDateTime();
19734
19735 wxPyEndAllowThreads(__tstate);
19736 if (PyErr_Occurred()) SWIG_fail;
19737 }
19738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19739 return resultobj;
19740 fail:
19741 return NULL;
19742 }
19743
19744
19745 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19746 PyObject *resultobj;
19747 time_t arg1 ;
19748 wxDateTime *result;
19749 PyObject * obj0 = 0 ;
19750 char *kwnames[] = {
19751 (char *) "timet", NULL
19752 };
19753
19754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19755 {
19756 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19757 if (SWIG_arg_fail(1)) SWIG_fail;
19758 }
19759 {
19760 PyThreadState* __tstate = wxPyBeginAllowThreads();
19761 result = (wxDateTime *)new wxDateTime(arg1);
19762
19763 wxPyEndAllowThreads(__tstate);
19764 if (PyErr_Occurred()) SWIG_fail;
19765 }
19766 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19767 return resultobj;
19768 fail:
19769 return NULL;
19770 }
19771
19772
19773 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19774 PyObject *resultobj;
19775 double arg1 ;
19776 wxDateTime *result;
19777 PyObject * obj0 = 0 ;
19778 char *kwnames[] = {
19779 (char *) "jdn", NULL
19780 };
19781
19782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19783 {
19784 arg1 = (double)(SWIG_As_double(obj0));
19785 if (SWIG_arg_fail(1)) SWIG_fail;
19786 }
19787 {
19788 PyThreadState* __tstate = wxPyBeginAllowThreads();
19789 result = (wxDateTime *)new wxDateTime(arg1);
19790
19791 wxPyEndAllowThreads(__tstate);
19792 if (PyErr_Occurred()) SWIG_fail;
19793 }
19794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19795 return resultobj;
19796 fail:
19797 return NULL;
19798 }
19799
19800
19801 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19802 PyObject *resultobj;
19803 int arg1 ;
19804 int arg2 = (int) 0 ;
19805 int arg3 = (int) 0 ;
19806 int arg4 = (int) 0 ;
19807 wxDateTime *result;
19808 PyObject * obj0 = 0 ;
19809 PyObject * obj1 = 0 ;
19810 PyObject * obj2 = 0 ;
19811 PyObject * obj3 = 0 ;
19812 char *kwnames[] = {
19813 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19814 };
19815
19816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19817 {
19818 arg1 = (int)(SWIG_As_int(obj0));
19819 if (SWIG_arg_fail(1)) SWIG_fail;
19820 }
19821 if (obj1) {
19822 {
19823 arg2 = (int)(SWIG_As_int(obj1));
19824 if (SWIG_arg_fail(2)) SWIG_fail;
19825 }
19826 }
19827 if (obj2) {
19828 {
19829 arg3 = (int)(SWIG_As_int(obj2));
19830 if (SWIG_arg_fail(3)) SWIG_fail;
19831 }
19832 }
19833 if (obj3) {
19834 {
19835 arg4 = (int)(SWIG_As_int(obj3));
19836 if (SWIG_arg_fail(4)) SWIG_fail;
19837 }
19838 }
19839 {
19840 PyThreadState* __tstate = wxPyBeginAllowThreads();
19841 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19842
19843 wxPyEndAllowThreads(__tstate);
19844 if (PyErr_Occurred()) SWIG_fail;
19845 }
19846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19847 return resultobj;
19848 fail:
19849 return NULL;
19850 }
19851
19852
19853 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19854 PyObject *resultobj;
19855 int arg1 ;
19856 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19857 int arg3 = (int) wxDateTime::Inv_Year ;
19858 int arg4 = (int) 0 ;
19859 int arg5 = (int) 0 ;
19860 int arg6 = (int) 0 ;
19861 int arg7 = (int) 0 ;
19862 wxDateTime *result;
19863 PyObject * obj0 = 0 ;
19864 PyObject * obj1 = 0 ;
19865 PyObject * obj2 = 0 ;
19866 PyObject * obj3 = 0 ;
19867 PyObject * obj4 = 0 ;
19868 PyObject * obj5 = 0 ;
19869 PyObject * obj6 = 0 ;
19870 char *kwnames[] = {
19871 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19872 };
19873
19874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19875 {
19876 arg1 = (int)(SWIG_As_int(obj0));
19877 if (SWIG_arg_fail(1)) SWIG_fail;
19878 }
19879 if (obj1) {
19880 {
19881 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19882 if (SWIG_arg_fail(2)) SWIG_fail;
19883 }
19884 }
19885 if (obj2) {
19886 {
19887 arg3 = (int)(SWIG_As_int(obj2));
19888 if (SWIG_arg_fail(3)) SWIG_fail;
19889 }
19890 }
19891 if (obj3) {
19892 {
19893 arg4 = (int)(SWIG_As_int(obj3));
19894 if (SWIG_arg_fail(4)) SWIG_fail;
19895 }
19896 }
19897 if (obj4) {
19898 {
19899 arg5 = (int)(SWIG_As_int(obj4));
19900 if (SWIG_arg_fail(5)) SWIG_fail;
19901 }
19902 }
19903 if (obj5) {
19904 {
19905 arg6 = (int)(SWIG_As_int(obj5));
19906 if (SWIG_arg_fail(6)) SWIG_fail;
19907 }
19908 }
19909 if (obj6) {
19910 {
19911 arg7 = (int)(SWIG_As_int(obj6));
19912 if (SWIG_arg_fail(7)) SWIG_fail;
19913 }
19914 }
19915 {
19916 PyThreadState* __tstate = wxPyBeginAllowThreads();
19917 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19918
19919 wxPyEndAllowThreads(__tstate);
19920 if (PyErr_Occurred()) SWIG_fail;
19921 }
19922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19923 return resultobj;
19924 fail:
19925 return NULL;
19926 }
19927
19928
19929 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19930 PyObject *resultobj;
19931 wxDateTime *arg1 = (wxDateTime *) 0 ;
19932 PyObject * obj0 = 0 ;
19933 char *kwnames[] = {
19934 (char *) "self", NULL
19935 };
19936
19937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19939 if (SWIG_arg_fail(1)) SWIG_fail;
19940 {
19941 PyThreadState* __tstate = wxPyBeginAllowThreads();
19942 delete arg1;
19943
19944 wxPyEndAllowThreads(__tstate);
19945 if (PyErr_Occurred()) SWIG_fail;
19946 }
19947 Py_INCREF(Py_None); resultobj = Py_None;
19948 return resultobj;
19949 fail:
19950 return NULL;
19951 }
19952
19953
19954 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19955 PyObject *resultobj;
19956 wxDateTime *arg1 = (wxDateTime *) 0 ;
19957 wxDateTime *result;
19958 PyObject * obj0 = 0 ;
19959 char *kwnames[] = {
19960 (char *) "self", NULL
19961 };
19962
19963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19965 if (SWIG_arg_fail(1)) SWIG_fail;
19966 {
19967 PyThreadState* __tstate = wxPyBeginAllowThreads();
19968 {
19969 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19970 result = (wxDateTime *) &_result_ref;
19971 }
19972
19973 wxPyEndAllowThreads(__tstate);
19974 if (PyErr_Occurred()) SWIG_fail;
19975 }
19976 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19977 return resultobj;
19978 fail:
19979 return NULL;
19980 }
19981
19982
19983 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19984 PyObject *resultobj;
19985 wxDateTime *arg1 = (wxDateTime *) 0 ;
19986 time_t arg2 ;
19987 wxDateTime *result;
19988 PyObject * obj0 = 0 ;
19989 PyObject * obj1 = 0 ;
19990 char *kwnames[] = {
19991 (char *) "self",(char *) "timet", NULL
19992 };
19993
19994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19996 if (SWIG_arg_fail(1)) SWIG_fail;
19997 {
19998 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19999 if (SWIG_arg_fail(2)) SWIG_fail;
20000 }
20001 {
20002 PyThreadState* __tstate = wxPyBeginAllowThreads();
20003 {
20004 wxDateTime &_result_ref = (arg1)->Set(arg2);
20005 result = (wxDateTime *) &_result_ref;
20006 }
20007
20008 wxPyEndAllowThreads(__tstate);
20009 if (PyErr_Occurred()) SWIG_fail;
20010 }
20011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20012 return resultobj;
20013 fail:
20014 return NULL;
20015 }
20016
20017
20018 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20019 PyObject *resultobj;
20020 wxDateTime *arg1 = (wxDateTime *) 0 ;
20021 double arg2 ;
20022 wxDateTime *result;
20023 PyObject * obj0 = 0 ;
20024 PyObject * obj1 = 0 ;
20025 char *kwnames[] = {
20026 (char *) "self",(char *) "jdn", NULL
20027 };
20028
20029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
20030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20031 if (SWIG_arg_fail(1)) SWIG_fail;
20032 {
20033 arg2 = (double)(SWIG_As_double(obj1));
20034 if (SWIG_arg_fail(2)) SWIG_fail;
20035 }
20036 {
20037 PyThreadState* __tstate = wxPyBeginAllowThreads();
20038 {
20039 wxDateTime &_result_ref = (arg1)->Set(arg2);
20040 result = (wxDateTime *) &_result_ref;
20041 }
20042
20043 wxPyEndAllowThreads(__tstate);
20044 if (PyErr_Occurred()) SWIG_fail;
20045 }
20046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20047 return resultobj;
20048 fail:
20049 return NULL;
20050 }
20051
20052
20053 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20054 PyObject *resultobj;
20055 wxDateTime *arg1 = (wxDateTime *) 0 ;
20056 int arg2 ;
20057 int arg3 = (int) 0 ;
20058 int arg4 = (int) 0 ;
20059 int arg5 = (int) 0 ;
20060 wxDateTime *result;
20061 PyObject * obj0 = 0 ;
20062 PyObject * obj1 = 0 ;
20063 PyObject * obj2 = 0 ;
20064 PyObject * obj3 = 0 ;
20065 PyObject * obj4 = 0 ;
20066 char *kwnames[] = {
20067 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20068 };
20069
20070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20072 if (SWIG_arg_fail(1)) SWIG_fail;
20073 {
20074 arg2 = (int)(SWIG_As_int(obj1));
20075 if (SWIG_arg_fail(2)) SWIG_fail;
20076 }
20077 if (obj2) {
20078 {
20079 arg3 = (int)(SWIG_As_int(obj2));
20080 if (SWIG_arg_fail(3)) SWIG_fail;
20081 }
20082 }
20083 if (obj3) {
20084 {
20085 arg4 = (int)(SWIG_As_int(obj3));
20086 if (SWIG_arg_fail(4)) SWIG_fail;
20087 }
20088 }
20089 if (obj4) {
20090 {
20091 arg5 = (int)(SWIG_As_int(obj4));
20092 if (SWIG_arg_fail(5)) SWIG_fail;
20093 }
20094 }
20095 {
20096 PyThreadState* __tstate = wxPyBeginAllowThreads();
20097 {
20098 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20099 result = (wxDateTime *) &_result_ref;
20100 }
20101
20102 wxPyEndAllowThreads(__tstate);
20103 if (PyErr_Occurred()) SWIG_fail;
20104 }
20105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20106 return resultobj;
20107 fail:
20108 return NULL;
20109 }
20110
20111
20112 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20113 PyObject *resultobj;
20114 wxDateTime *arg1 = (wxDateTime *) 0 ;
20115 int arg2 ;
20116 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20117 int arg4 = (int) wxDateTime::Inv_Year ;
20118 int arg5 = (int) 0 ;
20119 int arg6 = (int) 0 ;
20120 int arg7 = (int) 0 ;
20121 int arg8 = (int) 0 ;
20122 wxDateTime *result;
20123 PyObject * obj0 = 0 ;
20124 PyObject * obj1 = 0 ;
20125 PyObject * obj2 = 0 ;
20126 PyObject * obj3 = 0 ;
20127 PyObject * obj4 = 0 ;
20128 PyObject * obj5 = 0 ;
20129 PyObject * obj6 = 0 ;
20130 PyObject * obj7 = 0 ;
20131 char *kwnames[] = {
20132 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20133 };
20134
20135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20137 if (SWIG_arg_fail(1)) SWIG_fail;
20138 {
20139 arg2 = (int)(SWIG_As_int(obj1));
20140 if (SWIG_arg_fail(2)) SWIG_fail;
20141 }
20142 if (obj2) {
20143 {
20144 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20145 if (SWIG_arg_fail(3)) SWIG_fail;
20146 }
20147 }
20148 if (obj3) {
20149 {
20150 arg4 = (int)(SWIG_As_int(obj3));
20151 if (SWIG_arg_fail(4)) SWIG_fail;
20152 }
20153 }
20154 if (obj4) {
20155 {
20156 arg5 = (int)(SWIG_As_int(obj4));
20157 if (SWIG_arg_fail(5)) SWIG_fail;
20158 }
20159 }
20160 if (obj5) {
20161 {
20162 arg6 = (int)(SWIG_As_int(obj5));
20163 if (SWIG_arg_fail(6)) SWIG_fail;
20164 }
20165 }
20166 if (obj6) {
20167 {
20168 arg7 = (int)(SWIG_As_int(obj6));
20169 if (SWIG_arg_fail(7)) SWIG_fail;
20170 }
20171 }
20172 if (obj7) {
20173 {
20174 arg8 = (int)(SWIG_As_int(obj7));
20175 if (SWIG_arg_fail(8)) SWIG_fail;
20176 }
20177 }
20178 {
20179 PyThreadState* __tstate = wxPyBeginAllowThreads();
20180 {
20181 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20182 result = (wxDateTime *) &_result_ref;
20183 }
20184
20185 wxPyEndAllowThreads(__tstate);
20186 if (PyErr_Occurred()) SWIG_fail;
20187 }
20188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20189 return resultobj;
20190 fail:
20191 return NULL;
20192 }
20193
20194
20195 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20196 PyObject *resultobj;
20197 wxDateTime *arg1 = (wxDateTime *) 0 ;
20198 wxDateTime *result;
20199 PyObject * obj0 = 0 ;
20200 char *kwnames[] = {
20201 (char *) "self", NULL
20202 };
20203
20204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20206 if (SWIG_arg_fail(1)) SWIG_fail;
20207 {
20208 PyThreadState* __tstate = wxPyBeginAllowThreads();
20209 {
20210 wxDateTime &_result_ref = (arg1)->ResetTime();
20211 result = (wxDateTime *) &_result_ref;
20212 }
20213
20214 wxPyEndAllowThreads(__tstate);
20215 if (PyErr_Occurred()) SWIG_fail;
20216 }
20217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20218 return resultobj;
20219 fail:
20220 return NULL;
20221 }
20222
20223
20224 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20225 PyObject *resultobj;
20226 wxDateTime *arg1 = (wxDateTime *) 0 ;
20227 int arg2 ;
20228 wxDateTime *result;
20229 PyObject * obj0 = 0 ;
20230 PyObject * obj1 = 0 ;
20231 char *kwnames[] = {
20232 (char *) "self",(char *) "year", NULL
20233 };
20234
20235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20237 if (SWIG_arg_fail(1)) SWIG_fail;
20238 {
20239 arg2 = (int)(SWIG_As_int(obj1));
20240 if (SWIG_arg_fail(2)) SWIG_fail;
20241 }
20242 {
20243 PyThreadState* __tstate = wxPyBeginAllowThreads();
20244 {
20245 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20246 result = (wxDateTime *) &_result_ref;
20247 }
20248
20249 wxPyEndAllowThreads(__tstate);
20250 if (PyErr_Occurred()) SWIG_fail;
20251 }
20252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20253 return resultobj;
20254 fail:
20255 return NULL;
20256 }
20257
20258
20259 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20260 PyObject *resultobj;
20261 wxDateTime *arg1 = (wxDateTime *) 0 ;
20262 wxDateTime::Month arg2 ;
20263 wxDateTime *result;
20264 PyObject * obj0 = 0 ;
20265 PyObject * obj1 = 0 ;
20266 char *kwnames[] = {
20267 (char *) "self",(char *) "month", NULL
20268 };
20269
20270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20272 if (SWIG_arg_fail(1)) SWIG_fail;
20273 {
20274 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20275 if (SWIG_arg_fail(2)) SWIG_fail;
20276 }
20277 {
20278 PyThreadState* __tstate = wxPyBeginAllowThreads();
20279 {
20280 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20281 result = (wxDateTime *) &_result_ref;
20282 }
20283
20284 wxPyEndAllowThreads(__tstate);
20285 if (PyErr_Occurred()) SWIG_fail;
20286 }
20287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20288 return resultobj;
20289 fail:
20290 return NULL;
20291 }
20292
20293
20294 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20295 PyObject *resultobj;
20296 wxDateTime *arg1 = (wxDateTime *) 0 ;
20297 int arg2 ;
20298 wxDateTime *result;
20299 PyObject * obj0 = 0 ;
20300 PyObject * obj1 = 0 ;
20301 char *kwnames[] = {
20302 (char *) "self",(char *) "day", NULL
20303 };
20304
20305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20307 if (SWIG_arg_fail(1)) SWIG_fail;
20308 {
20309 arg2 = (int)(SWIG_As_int(obj1));
20310 if (SWIG_arg_fail(2)) SWIG_fail;
20311 }
20312 {
20313 PyThreadState* __tstate = wxPyBeginAllowThreads();
20314 {
20315 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20316 result = (wxDateTime *) &_result_ref;
20317 }
20318
20319 wxPyEndAllowThreads(__tstate);
20320 if (PyErr_Occurred()) SWIG_fail;
20321 }
20322 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20323 return resultobj;
20324 fail:
20325 return NULL;
20326 }
20327
20328
20329 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20330 PyObject *resultobj;
20331 wxDateTime *arg1 = (wxDateTime *) 0 ;
20332 int arg2 ;
20333 wxDateTime *result;
20334 PyObject * obj0 = 0 ;
20335 PyObject * obj1 = 0 ;
20336 char *kwnames[] = {
20337 (char *) "self",(char *) "hour", NULL
20338 };
20339
20340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20342 if (SWIG_arg_fail(1)) SWIG_fail;
20343 {
20344 arg2 = (int)(SWIG_As_int(obj1));
20345 if (SWIG_arg_fail(2)) SWIG_fail;
20346 }
20347 {
20348 PyThreadState* __tstate = wxPyBeginAllowThreads();
20349 {
20350 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20351 result = (wxDateTime *) &_result_ref;
20352 }
20353
20354 wxPyEndAllowThreads(__tstate);
20355 if (PyErr_Occurred()) SWIG_fail;
20356 }
20357 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20358 return resultobj;
20359 fail:
20360 return NULL;
20361 }
20362
20363
20364 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20365 PyObject *resultobj;
20366 wxDateTime *arg1 = (wxDateTime *) 0 ;
20367 int arg2 ;
20368 wxDateTime *result;
20369 PyObject * obj0 = 0 ;
20370 PyObject * obj1 = 0 ;
20371 char *kwnames[] = {
20372 (char *) "self",(char *) "minute", NULL
20373 };
20374
20375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20377 if (SWIG_arg_fail(1)) SWIG_fail;
20378 {
20379 arg2 = (int)(SWIG_As_int(obj1));
20380 if (SWIG_arg_fail(2)) SWIG_fail;
20381 }
20382 {
20383 PyThreadState* __tstate = wxPyBeginAllowThreads();
20384 {
20385 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20386 result = (wxDateTime *) &_result_ref;
20387 }
20388
20389 wxPyEndAllowThreads(__tstate);
20390 if (PyErr_Occurred()) SWIG_fail;
20391 }
20392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20393 return resultobj;
20394 fail:
20395 return NULL;
20396 }
20397
20398
20399 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20400 PyObject *resultobj;
20401 wxDateTime *arg1 = (wxDateTime *) 0 ;
20402 int arg2 ;
20403 wxDateTime *result;
20404 PyObject * obj0 = 0 ;
20405 PyObject * obj1 = 0 ;
20406 char *kwnames[] = {
20407 (char *) "self",(char *) "second", NULL
20408 };
20409
20410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20412 if (SWIG_arg_fail(1)) SWIG_fail;
20413 {
20414 arg2 = (int)(SWIG_As_int(obj1));
20415 if (SWIG_arg_fail(2)) SWIG_fail;
20416 }
20417 {
20418 PyThreadState* __tstate = wxPyBeginAllowThreads();
20419 {
20420 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20421 result = (wxDateTime *) &_result_ref;
20422 }
20423
20424 wxPyEndAllowThreads(__tstate);
20425 if (PyErr_Occurred()) SWIG_fail;
20426 }
20427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20428 return resultobj;
20429 fail:
20430 return NULL;
20431 }
20432
20433
20434 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20435 PyObject *resultobj;
20436 wxDateTime *arg1 = (wxDateTime *) 0 ;
20437 int arg2 ;
20438 wxDateTime *result;
20439 PyObject * obj0 = 0 ;
20440 PyObject * obj1 = 0 ;
20441 char *kwnames[] = {
20442 (char *) "self",(char *) "millisecond", NULL
20443 };
20444
20445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20447 if (SWIG_arg_fail(1)) SWIG_fail;
20448 {
20449 arg2 = (int)(SWIG_As_int(obj1));
20450 if (SWIG_arg_fail(2)) SWIG_fail;
20451 }
20452 {
20453 PyThreadState* __tstate = wxPyBeginAllowThreads();
20454 {
20455 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20456 result = (wxDateTime *) &_result_ref;
20457 }
20458
20459 wxPyEndAllowThreads(__tstate);
20460 if (PyErr_Occurred()) SWIG_fail;
20461 }
20462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20463 return resultobj;
20464 fail:
20465 return NULL;
20466 }
20467
20468
20469 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20470 PyObject *resultobj;
20471 wxDateTime *arg1 = (wxDateTime *) 0 ;
20472 wxDateTime::WeekDay arg2 ;
20473 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20474 wxDateTime *result;
20475 PyObject * obj0 = 0 ;
20476 PyObject * obj1 = 0 ;
20477 PyObject * obj2 = 0 ;
20478 char *kwnames[] = {
20479 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20480 };
20481
20482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20484 if (SWIG_arg_fail(1)) SWIG_fail;
20485 {
20486 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20487 if (SWIG_arg_fail(2)) SWIG_fail;
20488 }
20489 if (obj2) {
20490 {
20491 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20492 if (SWIG_arg_fail(3)) SWIG_fail;
20493 }
20494 }
20495 {
20496 PyThreadState* __tstate = wxPyBeginAllowThreads();
20497 {
20498 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20499 result = (wxDateTime *) &_result_ref;
20500 }
20501
20502 wxPyEndAllowThreads(__tstate);
20503 if (PyErr_Occurred()) SWIG_fail;
20504 }
20505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20506 return resultobj;
20507 fail:
20508 return NULL;
20509 }
20510
20511
20512 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20513 PyObject *resultobj;
20514 wxDateTime *arg1 = (wxDateTime *) 0 ;
20515 wxDateTime::WeekDay arg2 ;
20516 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20517 wxDateTime result;
20518 PyObject * obj0 = 0 ;
20519 PyObject * obj1 = 0 ;
20520 PyObject * obj2 = 0 ;
20521 char *kwnames[] = {
20522 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20523 };
20524
20525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20527 if (SWIG_arg_fail(1)) SWIG_fail;
20528 {
20529 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20530 if (SWIG_arg_fail(2)) SWIG_fail;
20531 }
20532 if (obj2) {
20533 {
20534 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20535 if (SWIG_arg_fail(3)) SWIG_fail;
20536 }
20537 }
20538 {
20539 PyThreadState* __tstate = wxPyBeginAllowThreads();
20540 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20541
20542 wxPyEndAllowThreads(__tstate);
20543 if (PyErr_Occurred()) SWIG_fail;
20544 }
20545 {
20546 wxDateTime * resultptr;
20547 resultptr = new wxDateTime((wxDateTime &)(result));
20548 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20549 }
20550 return resultobj;
20551 fail:
20552 return NULL;
20553 }
20554
20555
20556 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20557 PyObject *resultobj;
20558 wxDateTime *arg1 = (wxDateTime *) 0 ;
20559 wxDateTime::WeekDay arg2 ;
20560 wxDateTime *result;
20561 PyObject * obj0 = 0 ;
20562 PyObject * obj1 = 0 ;
20563 char *kwnames[] = {
20564 (char *) "self",(char *) "weekday", NULL
20565 };
20566
20567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20569 if (SWIG_arg_fail(1)) SWIG_fail;
20570 {
20571 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20572 if (SWIG_arg_fail(2)) SWIG_fail;
20573 }
20574 {
20575 PyThreadState* __tstate = wxPyBeginAllowThreads();
20576 {
20577 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20578 result = (wxDateTime *) &_result_ref;
20579 }
20580
20581 wxPyEndAllowThreads(__tstate);
20582 if (PyErr_Occurred()) SWIG_fail;
20583 }
20584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20585 return resultobj;
20586 fail:
20587 return NULL;
20588 }
20589
20590
20591 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20592 PyObject *resultobj;
20593 wxDateTime *arg1 = (wxDateTime *) 0 ;
20594 wxDateTime::WeekDay arg2 ;
20595 wxDateTime result;
20596 PyObject * obj0 = 0 ;
20597 PyObject * obj1 = 0 ;
20598 char *kwnames[] = {
20599 (char *) "self",(char *) "weekday", NULL
20600 };
20601
20602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20604 if (SWIG_arg_fail(1)) SWIG_fail;
20605 {
20606 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20607 if (SWIG_arg_fail(2)) SWIG_fail;
20608 }
20609 {
20610 PyThreadState* __tstate = wxPyBeginAllowThreads();
20611 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20612
20613 wxPyEndAllowThreads(__tstate);
20614 if (PyErr_Occurred()) SWIG_fail;
20615 }
20616 {
20617 wxDateTime * resultptr;
20618 resultptr = new wxDateTime((wxDateTime &)(result));
20619 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20620 }
20621 return resultobj;
20622 fail:
20623 return NULL;
20624 }
20625
20626
20627 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20628 PyObject *resultobj;
20629 wxDateTime *arg1 = (wxDateTime *) 0 ;
20630 wxDateTime::WeekDay arg2 ;
20631 wxDateTime *result;
20632 PyObject * obj0 = 0 ;
20633 PyObject * obj1 = 0 ;
20634 char *kwnames[] = {
20635 (char *) "self",(char *) "weekday", NULL
20636 };
20637
20638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20640 if (SWIG_arg_fail(1)) SWIG_fail;
20641 {
20642 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20643 if (SWIG_arg_fail(2)) SWIG_fail;
20644 }
20645 {
20646 PyThreadState* __tstate = wxPyBeginAllowThreads();
20647 {
20648 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20649 result = (wxDateTime *) &_result_ref;
20650 }
20651
20652 wxPyEndAllowThreads(__tstate);
20653 if (PyErr_Occurred()) SWIG_fail;
20654 }
20655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20656 return resultobj;
20657 fail:
20658 return NULL;
20659 }
20660
20661
20662 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20663 PyObject *resultobj;
20664 wxDateTime *arg1 = (wxDateTime *) 0 ;
20665 wxDateTime::WeekDay arg2 ;
20666 wxDateTime result;
20667 PyObject * obj0 = 0 ;
20668 PyObject * obj1 = 0 ;
20669 char *kwnames[] = {
20670 (char *) "self",(char *) "weekday", NULL
20671 };
20672
20673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20675 if (SWIG_arg_fail(1)) SWIG_fail;
20676 {
20677 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20678 if (SWIG_arg_fail(2)) SWIG_fail;
20679 }
20680 {
20681 PyThreadState* __tstate = wxPyBeginAllowThreads();
20682 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20683
20684 wxPyEndAllowThreads(__tstate);
20685 if (PyErr_Occurred()) SWIG_fail;
20686 }
20687 {
20688 wxDateTime * resultptr;
20689 resultptr = new wxDateTime((wxDateTime &)(result));
20690 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20691 }
20692 return resultobj;
20693 fail:
20694 return NULL;
20695 }
20696
20697
20698 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20699 PyObject *resultobj;
20700 wxDateTime *arg1 = (wxDateTime *) 0 ;
20701 wxDateTime::WeekDay arg2 ;
20702 int arg3 = (int) 1 ;
20703 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20704 int arg5 = (int) wxDateTime::Inv_Year ;
20705 bool result;
20706 PyObject * obj0 = 0 ;
20707 PyObject * obj1 = 0 ;
20708 PyObject * obj2 = 0 ;
20709 PyObject * obj3 = 0 ;
20710 PyObject * obj4 = 0 ;
20711 char *kwnames[] = {
20712 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20713 };
20714
20715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20717 if (SWIG_arg_fail(1)) SWIG_fail;
20718 {
20719 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20720 if (SWIG_arg_fail(2)) SWIG_fail;
20721 }
20722 if (obj2) {
20723 {
20724 arg3 = (int)(SWIG_As_int(obj2));
20725 if (SWIG_arg_fail(3)) SWIG_fail;
20726 }
20727 }
20728 if (obj3) {
20729 {
20730 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20731 if (SWIG_arg_fail(4)) SWIG_fail;
20732 }
20733 }
20734 if (obj4) {
20735 {
20736 arg5 = (int)(SWIG_As_int(obj4));
20737 if (SWIG_arg_fail(5)) SWIG_fail;
20738 }
20739 }
20740 {
20741 PyThreadState* __tstate = wxPyBeginAllowThreads();
20742 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20743
20744 wxPyEndAllowThreads(__tstate);
20745 if (PyErr_Occurred()) SWIG_fail;
20746 }
20747 {
20748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20749 }
20750 return resultobj;
20751 fail:
20752 return NULL;
20753 }
20754
20755
20756 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20757 PyObject *resultobj;
20758 wxDateTime *arg1 = (wxDateTime *) 0 ;
20759 wxDateTime::WeekDay arg2 ;
20760 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20761 int arg4 = (int) wxDateTime::Inv_Year ;
20762 bool result;
20763 PyObject * obj0 = 0 ;
20764 PyObject * obj1 = 0 ;
20765 PyObject * obj2 = 0 ;
20766 PyObject * obj3 = 0 ;
20767 char *kwnames[] = {
20768 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20769 };
20770
20771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20773 if (SWIG_arg_fail(1)) SWIG_fail;
20774 {
20775 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20776 if (SWIG_arg_fail(2)) SWIG_fail;
20777 }
20778 if (obj2) {
20779 {
20780 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20781 if (SWIG_arg_fail(3)) SWIG_fail;
20782 }
20783 }
20784 if (obj3) {
20785 {
20786 arg4 = (int)(SWIG_As_int(obj3));
20787 if (SWIG_arg_fail(4)) SWIG_fail;
20788 }
20789 }
20790 {
20791 PyThreadState* __tstate = wxPyBeginAllowThreads();
20792 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20793
20794 wxPyEndAllowThreads(__tstate);
20795 if (PyErr_Occurred()) SWIG_fail;
20796 }
20797 {
20798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20799 }
20800 return resultobj;
20801 fail:
20802 return NULL;
20803 }
20804
20805
20806 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20807 PyObject *resultobj;
20808 wxDateTime *arg1 = (wxDateTime *) 0 ;
20809 wxDateTime::WeekDay arg2 ;
20810 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20811 int arg4 = (int) wxDateTime::Inv_Year ;
20812 wxDateTime result;
20813 PyObject * obj0 = 0 ;
20814 PyObject * obj1 = 0 ;
20815 PyObject * obj2 = 0 ;
20816 PyObject * obj3 = 0 ;
20817 char *kwnames[] = {
20818 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20819 };
20820
20821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20823 if (SWIG_arg_fail(1)) SWIG_fail;
20824 {
20825 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20826 if (SWIG_arg_fail(2)) SWIG_fail;
20827 }
20828 if (obj2) {
20829 {
20830 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20831 if (SWIG_arg_fail(3)) SWIG_fail;
20832 }
20833 }
20834 if (obj3) {
20835 {
20836 arg4 = (int)(SWIG_As_int(obj3));
20837 if (SWIG_arg_fail(4)) SWIG_fail;
20838 }
20839 }
20840 {
20841 PyThreadState* __tstate = wxPyBeginAllowThreads();
20842 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20843
20844 wxPyEndAllowThreads(__tstate);
20845 if (PyErr_Occurred()) SWIG_fail;
20846 }
20847 {
20848 wxDateTime * resultptr;
20849 resultptr = new wxDateTime((wxDateTime &)(result));
20850 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20851 }
20852 return resultobj;
20853 fail:
20854 return NULL;
20855 }
20856
20857
20858 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20859 PyObject *resultobj;
20860 wxDateTime *arg1 = (wxDateTime *) 0 ;
20861 int arg2 ;
20862 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20863 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20864 bool result;
20865 PyObject * obj0 = 0 ;
20866 PyObject * obj1 = 0 ;
20867 PyObject * obj2 = 0 ;
20868 PyObject * obj3 = 0 ;
20869 char *kwnames[] = {
20870 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20871 };
20872
20873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20875 if (SWIG_arg_fail(1)) SWIG_fail;
20876 {
20877 arg2 = (int)(SWIG_As_int(obj1));
20878 if (SWIG_arg_fail(2)) SWIG_fail;
20879 }
20880 if (obj2) {
20881 {
20882 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20883 if (SWIG_arg_fail(3)) SWIG_fail;
20884 }
20885 }
20886 if (obj3) {
20887 {
20888 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20889 if (SWIG_arg_fail(4)) SWIG_fail;
20890 }
20891 }
20892 {
20893 PyThreadState* __tstate = wxPyBeginAllowThreads();
20894 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20895
20896 wxPyEndAllowThreads(__tstate);
20897 if (PyErr_Occurred()) SWIG_fail;
20898 }
20899 {
20900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20901 }
20902 return resultobj;
20903 fail:
20904 return NULL;
20905 }
20906
20907
20908 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20909 PyObject *resultobj;
20910 wxDateTime *arg1 = (wxDateTime *) 0 ;
20911 int arg2 ;
20912 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20913 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20914 wxDateTime result;
20915 PyObject * obj0 = 0 ;
20916 PyObject * obj1 = 0 ;
20917 PyObject * obj2 = 0 ;
20918 PyObject * obj3 = 0 ;
20919 char *kwnames[] = {
20920 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20921 };
20922
20923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20925 if (SWIG_arg_fail(1)) SWIG_fail;
20926 {
20927 arg2 = (int)(SWIG_As_int(obj1));
20928 if (SWIG_arg_fail(2)) SWIG_fail;
20929 }
20930 if (obj2) {
20931 {
20932 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20933 if (SWIG_arg_fail(3)) SWIG_fail;
20934 }
20935 }
20936 if (obj3) {
20937 {
20938 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20939 if (SWIG_arg_fail(4)) SWIG_fail;
20940 }
20941 }
20942 {
20943 PyThreadState* __tstate = wxPyBeginAllowThreads();
20944 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20945
20946 wxPyEndAllowThreads(__tstate);
20947 if (PyErr_Occurred()) SWIG_fail;
20948 }
20949 {
20950 wxDateTime * resultptr;
20951 resultptr = new wxDateTime((wxDateTime &)(result));
20952 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20953 }
20954 return resultobj;
20955 fail:
20956 return NULL;
20957 }
20958
20959
20960 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20961 PyObject *resultobj;
20962 int arg1 ;
20963 int arg2 ;
20964 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20965 wxDateTime result;
20966 PyObject * obj0 = 0 ;
20967 PyObject * obj1 = 0 ;
20968 PyObject * obj2 = 0 ;
20969 char *kwnames[] = {
20970 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20971 };
20972
20973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20974 {
20975 arg1 = (int)(SWIG_As_int(obj0));
20976 if (SWIG_arg_fail(1)) SWIG_fail;
20977 }
20978 {
20979 arg2 = (int)(SWIG_As_int(obj1));
20980 if (SWIG_arg_fail(2)) SWIG_fail;
20981 }
20982 if (obj2) {
20983 {
20984 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20985 if (SWIG_arg_fail(3)) SWIG_fail;
20986 }
20987 }
20988 {
20989 PyThreadState* __tstate = wxPyBeginAllowThreads();
20990 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20991
20992 wxPyEndAllowThreads(__tstate);
20993 if (PyErr_Occurred()) SWIG_fail;
20994 }
20995 {
20996 wxDateTime * resultptr;
20997 resultptr = new wxDateTime((wxDateTime &)(result));
20998 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20999 }
21000 return resultobj;
21001 fail:
21002 return NULL;
21003 }
21004
21005
21006 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21007 PyObject *resultobj;
21008 wxDateTime *arg1 = (wxDateTime *) 0 ;
21009 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21010 int arg3 = (int) wxDateTime::Inv_Year ;
21011 wxDateTime *result;
21012 PyObject * obj0 = 0 ;
21013 PyObject * obj1 = 0 ;
21014 PyObject * obj2 = 0 ;
21015 char *kwnames[] = {
21016 (char *) "self",(char *) "month",(char *) "year", NULL
21017 };
21018
21019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21021 if (SWIG_arg_fail(1)) SWIG_fail;
21022 if (obj1) {
21023 {
21024 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21025 if (SWIG_arg_fail(2)) SWIG_fail;
21026 }
21027 }
21028 if (obj2) {
21029 {
21030 arg3 = (int)(SWIG_As_int(obj2));
21031 if (SWIG_arg_fail(3)) SWIG_fail;
21032 }
21033 }
21034 {
21035 PyThreadState* __tstate = wxPyBeginAllowThreads();
21036 {
21037 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
21038 result = (wxDateTime *) &_result_ref;
21039 }
21040
21041 wxPyEndAllowThreads(__tstate);
21042 if (PyErr_Occurred()) SWIG_fail;
21043 }
21044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21045 return resultobj;
21046 fail:
21047 return NULL;
21048 }
21049
21050
21051 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21052 PyObject *resultobj;
21053 wxDateTime *arg1 = (wxDateTime *) 0 ;
21054 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21055 int arg3 = (int) wxDateTime::Inv_Year ;
21056 wxDateTime result;
21057 PyObject * obj0 = 0 ;
21058 PyObject * obj1 = 0 ;
21059 PyObject * obj2 = 0 ;
21060 char *kwnames[] = {
21061 (char *) "self",(char *) "month",(char *) "year", NULL
21062 };
21063
21064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21066 if (SWIG_arg_fail(1)) SWIG_fail;
21067 if (obj1) {
21068 {
21069 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21070 if (SWIG_arg_fail(2)) SWIG_fail;
21071 }
21072 }
21073 if (obj2) {
21074 {
21075 arg3 = (int)(SWIG_As_int(obj2));
21076 if (SWIG_arg_fail(3)) SWIG_fail;
21077 }
21078 }
21079 {
21080 PyThreadState* __tstate = wxPyBeginAllowThreads();
21081 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21082
21083 wxPyEndAllowThreads(__tstate);
21084 if (PyErr_Occurred()) SWIG_fail;
21085 }
21086 {
21087 wxDateTime * resultptr;
21088 resultptr = new wxDateTime((wxDateTime &)(result));
21089 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21090 }
21091 return resultobj;
21092 fail:
21093 return NULL;
21094 }
21095
21096
21097 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21098 PyObject *resultobj;
21099 wxDateTime *arg1 = (wxDateTime *) 0 ;
21100 int arg2 ;
21101 wxDateTime *result;
21102 PyObject * obj0 = 0 ;
21103 PyObject * obj1 = 0 ;
21104 char *kwnames[] = {
21105 (char *) "self",(char *) "yday", NULL
21106 };
21107
21108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21110 if (SWIG_arg_fail(1)) SWIG_fail;
21111 {
21112 arg2 = (int)(SWIG_As_int(obj1));
21113 if (SWIG_arg_fail(2)) SWIG_fail;
21114 }
21115 {
21116 PyThreadState* __tstate = wxPyBeginAllowThreads();
21117 {
21118 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21119 result = (wxDateTime *) &_result_ref;
21120 }
21121
21122 wxPyEndAllowThreads(__tstate);
21123 if (PyErr_Occurred()) SWIG_fail;
21124 }
21125 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21126 return resultobj;
21127 fail:
21128 return NULL;
21129 }
21130
21131
21132 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21133 PyObject *resultobj;
21134 wxDateTime *arg1 = (wxDateTime *) 0 ;
21135 int arg2 ;
21136 wxDateTime result;
21137 PyObject * obj0 = 0 ;
21138 PyObject * obj1 = 0 ;
21139 char *kwnames[] = {
21140 (char *) "self",(char *) "yday", NULL
21141 };
21142
21143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21145 if (SWIG_arg_fail(1)) SWIG_fail;
21146 {
21147 arg2 = (int)(SWIG_As_int(obj1));
21148 if (SWIG_arg_fail(2)) SWIG_fail;
21149 }
21150 {
21151 PyThreadState* __tstate = wxPyBeginAllowThreads();
21152 result = (arg1)->GetYearDay(arg2);
21153
21154 wxPyEndAllowThreads(__tstate);
21155 if (PyErr_Occurred()) SWIG_fail;
21156 }
21157 {
21158 wxDateTime * resultptr;
21159 resultptr = new wxDateTime((wxDateTime &)(result));
21160 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21161 }
21162 return resultobj;
21163 fail:
21164 return NULL;
21165 }
21166
21167
21168 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21169 PyObject *resultobj;
21170 wxDateTime *arg1 = (wxDateTime *) 0 ;
21171 double result;
21172 PyObject * obj0 = 0 ;
21173 char *kwnames[] = {
21174 (char *) "self", NULL
21175 };
21176
21177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21179 if (SWIG_arg_fail(1)) SWIG_fail;
21180 {
21181 PyThreadState* __tstate = wxPyBeginAllowThreads();
21182 result = (double)(arg1)->GetJulianDayNumber();
21183
21184 wxPyEndAllowThreads(__tstate);
21185 if (PyErr_Occurred()) SWIG_fail;
21186 }
21187 {
21188 resultobj = SWIG_From_double((double)(result));
21189 }
21190 return resultobj;
21191 fail:
21192 return NULL;
21193 }
21194
21195
21196 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21197 PyObject *resultobj;
21198 wxDateTime *arg1 = (wxDateTime *) 0 ;
21199 double result;
21200 PyObject * obj0 = 0 ;
21201 char *kwnames[] = {
21202 (char *) "self", NULL
21203 };
21204
21205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21207 if (SWIG_arg_fail(1)) SWIG_fail;
21208 {
21209 PyThreadState* __tstate = wxPyBeginAllowThreads();
21210 result = (double)(arg1)->GetJDN();
21211
21212 wxPyEndAllowThreads(__tstate);
21213 if (PyErr_Occurred()) SWIG_fail;
21214 }
21215 {
21216 resultobj = SWIG_From_double((double)(result));
21217 }
21218 return resultobj;
21219 fail:
21220 return NULL;
21221 }
21222
21223
21224 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21225 PyObject *resultobj;
21226 wxDateTime *arg1 = (wxDateTime *) 0 ;
21227 double result;
21228 PyObject * obj0 = 0 ;
21229 char *kwnames[] = {
21230 (char *) "self", NULL
21231 };
21232
21233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21235 if (SWIG_arg_fail(1)) SWIG_fail;
21236 {
21237 PyThreadState* __tstate = wxPyBeginAllowThreads();
21238 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21239
21240 wxPyEndAllowThreads(__tstate);
21241 if (PyErr_Occurred()) SWIG_fail;
21242 }
21243 {
21244 resultobj = SWIG_From_double((double)(result));
21245 }
21246 return resultobj;
21247 fail:
21248 return NULL;
21249 }
21250
21251
21252 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21253 PyObject *resultobj;
21254 wxDateTime *arg1 = (wxDateTime *) 0 ;
21255 double result;
21256 PyObject * obj0 = 0 ;
21257 char *kwnames[] = {
21258 (char *) "self", NULL
21259 };
21260
21261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21263 if (SWIG_arg_fail(1)) SWIG_fail;
21264 {
21265 PyThreadState* __tstate = wxPyBeginAllowThreads();
21266 result = (double)(arg1)->GetMJD();
21267
21268 wxPyEndAllowThreads(__tstate);
21269 if (PyErr_Occurred()) SWIG_fail;
21270 }
21271 {
21272 resultobj = SWIG_From_double((double)(result));
21273 }
21274 return resultobj;
21275 fail:
21276 return NULL;
21277 }
21278
21279
21280 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21281 PyObject *resultobj;
21282 wxDateTime *arg1 = (wxDateTime *) 0 ;
21283 double result;
21284 PyObject * obj0 = 0 ;
21285 char *kwnames[] = {
21286 (char *) "self", NULL
21287 };
21288
21289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21291 if (SWIG_arg_fail(1)) SWIG_fail;
21292 {
21293 PyThreadState* __tstate = wxPyBeginAllowThreads();
21294 result = (double)(arg1)->GetRataDie();
21295
21296 wxPyEndAllowThreads(__tstate);
21297 if (PyErr_Occurred()) SWIG_fail;
21298 }
21299 {
21300 resultobj = SWIG_From_double((double)(result));
21301 }
21302 return resultobj;
21303 fail:
21304 return NULL;
21305 }
21306
21307
21308 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21309 PyObject *resultobj;
21310 wxDateTime *arg1 = (wxDateTime *) 0 ;
21311 wxDateTime::TimeZone *arg2 = 0 ;
21312 bool arg3 = (bool) false ;
21313 wxDateTime result;
21314 bool temp2 = false ;
21315 PyObject * obj0 = 0 ;
21316 PyObject * obj1 = 0 ;
21317 PyObject * obj2 = 0 ;
21318 char *kwnames[] = {
21319 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21320 };
21321
21322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21324 if (SWIG_arg_fail(1)) SWIG_fail;
21325 {
21326 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21327 temp2 = true;
21328 }
21329 if (obj2) {
21330 {
21331 arg3 = (bool)(SWIG_As_bool(obj2));
21332 if (SWIG_arg_fail(3)) SWIG_fail;
21333 }
21334 }
21335 {
21336 PyThreadState* __tstate = wxPyBeginAllowThreads();
21337 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21338
21339 wxPyEndAllowThreads(__tstate);
21340 if (PyErr_Occurred()) SWIG_fail;
21341 }
21342 {
21343 wxDateTime * resultptr;
21344 resultptr = new wxDateTime((wxDateTime &)(result));
21345 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21346 }
21347 {
21348 if (temp2) delete arg2;
21349 }
21350 return resultobj;
21351 fail:
21352 {
21353 if (temp2) delete arg2;
21354 }
21355 return NULL;
21356 }
21357
21358
21359 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21360 PyObject *resultobj;
21361 wxDateTime *arg1 = (wxDateTime *) 0 ;
21362 wxDateTime::TimeZone *arg2 = 0 ;
21363 bool arg3 = (bool) false ;
21364 wxDateTime *result;
21365 bool temp2 = false ;
21366 PyObject * obj0 = 0 ;
21367 PyObject * obj1 = 0 ;
21368 PyObject * obj2 = 0 ;
21369 char *kwnames[] = {
21370 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21371 };
21372
21373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21375 if (SWIG_arg_fail(1)) SWIG_fail;
21376 {
21377 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21378 temp2 = true;
21379 }
21380 if (obj2) {
21381 {
21382 arg3 = (bool)(SWIG_As_bool(obj2));
21383 if (SWIG_arg_fail(3)) SWIG_fail;
21384 }
21385 }
21386 {
21387 PyThreadState* __tstate = wxPyBeginAllowThreads();
21388 {
21389 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21390 result = (wxDateTime *) &_result_ref;
21391 }
21392
21393 wxPyEndAllowThreads(__tstate);
21394 if (PyErr_Occurred()) SWIG_fail;
21395 }
21396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21397 {
21398 if (temp2) delete arg2;
21399 }
21400 return resultobj;
21401 fail:
21402 {
21403 if (temp2) delete arg2;
21404 }
21405 return NULL;
21406 }
21407
21408
21409 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21410 PyObject *resultobj;
21411 wxDateTime *arg1 = (wxDateTime *) 0 ;
21412 bool arg2 = (bool) false ;
21413 wxDateTime result;
21414 PyObject * obj0 = 0 ;
21415 PyObject * obj1 = 0 ;
21416 char *kwnames[] = {
21417 (char *) "self",(char *) "noDST", NULL
21418 };
21419
21420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21422 if (SWIG_arg_fail(1)) SWIG_fail;
21423 if (obj1) {
21424 {
21425 arg2 = (bool)(SWIG_As_bool(obj1));
21426 if (SWIG_arg_fail(2)) SWIG_fail;
21427 }
21428 }
21429 {
21430 PyThreadState* __tstate = wxPyBeginAllowThreads();
21431 result = (arg1)->ToGMT(arg2);
21432
21433 wxPyEndAllowThreads(__tstate);
21434 if (PyErr_Occurred()) SWIG_fail;
21435 }
21436 {
21437 wxDateTime * resultptr;
21438 resultptr = new wxDateTime((wxDateTime &)(result));
21439 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21440 }
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21448 PyObject *resultobj;
21449 wxDateTime *arg1 = (wxDateTime *) 0 ;
21450 bool arg2 = (bool) false ;
21451 wxDateTime *result;
21452 PyObject * obj0 = 0 ;
21453 PyObject * obj1 = 0 ;
21454 char *kwnames[] = {
21455 (char *) "self",(char *) "noDST", NULL
21456 };
21457
21458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21460 if (SWIG_arg_fail(1)) SWIG_fail;
21461 if (obj1) {
21462 {
21463 arg2 = (bool)(SWIG_As_bool(obj1));
21464 if (SWIG_arg_fail(2)) SWIG_fail;
21465 }
21466 }
21467 {
21468 PyThreadState* __tstate = wxPyBeginAllowThreads();
21469 {
21470 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21471 result = (wxDateTime *) &_result_ref;
21472 }
21473
21474 wxPyEndAllowThreads(__tstate);
21475 if (PyErr_Occurred()) SWIG_fail;
21476 }
21477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21478 return resultobj;
21479 fail:
21480 return NULL;
21481 }
21482
21483
21484 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21485 PyObject *resultobj;
21486 wxDateTime *arg1 = (wxDateTime *) 0 ;
21487 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21488 int result;
21489 PyObject * obj0 = 0 ;
21490 PyObject * obj1 = 0 ;
21491 char *kwnames[] = {
21492 (char *) "self",(char *) "country", NULL
21493 };
21494
21495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21497 if (SWIG_arg_fail(1)) SWIG_fail;
21498 if (obj1) {
21499 {
21500 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21501 if (SWIG_arg_fail(2)) SWIG_fail;
21502 }
21503 }
21504 {
21505 PyThreadState* __tstate = wxPyBeginAllowThreads();
21506 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21507
21508 wxPyEndAllowThreads(__tstate);
21509 if (PyErr_Occurred()) SWIG_fail;
21510 }
21511 {
21512 resultobj = SWIG_From_int((int)(result));
21513 }
21514 return resultobj;
21515 fail:
21516 return NULL;
21517 }
21518
21519
21520 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21521 PyObject *resultobj;
21522 wxDateTime *arg1 = (wxDateTime *) 0 ;
21523 bool result;
21524 PyObject * obj0 = 0 ;
21525 char *kwnames[] = {
21526 (char *) "self", NULL
21527 };
21528
21529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21531 if (SWIG_arg_fail(1)) SWIG_fail;
21532 {
21533 PyThreadState* __tstate = wxPyBeginAllowThreads();
21534 result = (bool)((wxDateTime const *)arg1)->IsValid();
21535
21536 wxPyEndAllowThreads(__tstate);
21537 if (PyErr_Occurred()) SWIG_fail;
21538 }
21539 {
21540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21541 }
21542 return resultobj;
21543 fail:
21544 return NULL;
21545 }
21546
21547
21548 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21549 PyObject *resultobj;
21550 wxDateTime *arg1 = (wxDateTime *) 0 ;
21551 time_t result;
21552 PyObject * obj0 = 0 ;
21553 char *kwnames[] = {
21554 (char *) "self", NULL
21555 };
21556
21557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21559 if (SWIG_arg_fail(1)) SWIG_fail;
21560 {
21561 PyThreadState* __tstate = wxPyBeginAllowThreads();
21562 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21563
21564 wxPyEndAllowThreads(__tstate);
21565 if (PyErr_Occurred()) SWIG_fail;
21566 }
21567 {
21568 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21569 }
21570 return resultobj;
21571 fail:
21572 return NULL;
21573 }
21574
21575
21576 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21577 PyObject *resultobj;
21578 wxDateTime *arg1 = (wxDateTime *) 0 ;
21579 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21580 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21581 int result;
21582 bool temp2 = false ;
21583 PyObject * obj0 = 0 ;
21584 PyObject * obj1 = 0 ;
21585 char *kwnames[] = {
21586 (char *) "self",(char *) "tz", NULL
21587 };
21588
21589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21591 if (SWIG_arg_fail(1)) SWIG_fail;
21592 if (obj1) {
21593 {
21594 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21595 temp2 = true;
21596 }
21597 }
21598 {
21599 PyThreadState* __tstate = wxPyBeginAllowThreads();
21600 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21601
21602 wxPyEndAllowThreads(__tstate);
21603 if (PyErr_Occurred()) SWIG_fail;
21604 }
21605 {
21606 resultobj = SWIG_From_int((int)(result));
21607 }
21608 {
21609 if (temp2) delete arg2;
21610 }
21611 return resultobj;
21612 fail:
21613 {
21614 if (temp2) delete arg2;
21615 }
21616 return NULL;
21617 }
21618
21619
21620 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21621 PyObject *resultobj;
21622 wxDateTime *arg1 = (wxDateTime *) 0 ;
21623 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21624 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21625 wxDateTime::Month result;
21626 bool temp2 = false ;
21627 PyObject * obj0 = 0 ;
21628 PyObject * obj1 = 0 ;
21629 char *kwnames[] = {
21630 (char *) "self",(char *) "tz", NULL
21631 };
21632
21633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21635 if (SWIG_arg_fail(1)) SWIG_fail;
21636 if (obj1) {
21637 {
21638 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21639 temp2 = true;
21640 }
21641 }
21642 {
21643 PyThreadState* __tstate = wxPyBeginAllowThreads();
21644 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21645
21646 wxPyEndAllowThreads(__tstate);
21647 if (PyErr_Occurred()) SWIG_fail;
21648 }
21649 resultobj = SWIG_From_int((result));
21650 {
21651 if (temp2) delete arg2;
21652 }
21653 return resultobj;
21654 fail:
21655 {
21656 if (temp2) delete arg2;
21657 }
21658 return NULL;
21659 }
21660
21661
21662 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21663 PyObject *resultobj;
21664 wxDateTime *arg1 = (wxDateTime *) 0 ;
21665 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21666 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21667 int result;
21668 bool temp2 = false ;
21669 PyObject * obj0 = 0 ;
21670 PyObject * obj1 = 0 ;
21671 char *kwnames[] = {
21672 (char *) "self",(char *) "tz", NULL
21673 };
21674
21675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21677 if (SWIG_arg_fail(1)) SWIG_fail;
21678 if (obj1) {
21679 {
21680 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21681 temp2 = true;
21682 }
21683 }
21684 {
21685 PyThreadState* __tstate = wxPyBeginAllowThreads();
21686 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21687
21688 wxPyEndAllowThreads(__tstate);
21689 if (PyErr_Occurred()) SWIG_fail;
21690 }
21691 {
21692 resultobj = SWIG_From_int((int)(result));
21693 }
21694 {
21695 if (temp2) delete arg2;
21696 }
21697 return resultobj;
21698 fail:
21699 {
21700 if (temp2) delete arg2;
21701 }
21702 return NULL;
21703 }
21704
21705
21706 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21707 PyObject *resultobj;
21708 wxDateTime *arg1 = (wxDateTime *) 0 ;
21709 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21710 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21711 wxDateTime::WeekDay result;
21712 bool temp2 = false ;
21713 PyObject * obj0 = 0 ;
21714 PyObject * obj1 = 0 ;
21715 char *kwnames[] = {
21716 (char *) "self",(char *) "tz", NULL
21717 };
21718
21719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21721 if (SWIG_arg_fail(1)) SWIG_fail;
21722 if (obj1) {
21723 {
21724 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21725 temp2 = true;
21726 }
21727 }
21728 {
21729 PyThreadState* __tstate = wxPyBeginAllowThreads();
21730 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21731
21732 wxPyEndAllowThreads(__tstate);
21733 if (PyErr_Occurred()) SWIG_fail;
21734 }
21735 resultobj = SWIG_From_int((result));
21736 {
21737 if (temp2) delete arg2;
21738 }
21739 return resultobj;
21740 fail:
21741 {
21742 if (temp2) delete arg2;
21743 }
21744 return NULL;
21745 }
21746
21747
21748 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21749 PyObject *resultobj;
21750 wxDateTime *arg1 = (wxDateTime *) 0 ;
21751 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21752 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21753 int result;
21754 bool temp2 = false ;
21755 PyObject * obj0 = 0 ;
21756 PyObject * obj1 = 0 ;
21757 char *kwnames[] = {
21758 (char *) "self",(char *) "tz", NULL
21759 };
21760
21761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21763 if (SWIG_arg_fail(1)) SWIG_fail;
21764 if (obj1) {
21765 {
21766 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21767 temp2 = true;
21768 }
21769 }
21770 {
21771 PyThreadState* __tstate = wxPyBeginAllowThreads();
21772 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21773
21774 wxPyEndAllowThreads(__tstate);
21775 if (PyErr_Occurred()) SWIG_fail;
21776 }
21777 {
21778 resultobj = SWIG_From_int((int)(result));
21779 }
21780 {
21781 if (temp2) delete arg2;
21782 }
21783 return resultobj;
21784 fail:
21785 {
21786 if (temp2) delete arg2;
21787 }
21788 return NULL;
21789 }
21790
21791
21792 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21793 PyObject *resultobj;
21794 wxDateTime *arg1 = (wxDateTime *) 0 ;
21795 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21796 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21797 int result;
21798 bool temp2 = false ;
21799 PyObject * obj0 = 0 ;
21800 PyObject * obj1 = 0 ;
21801 char *kwnames[] = {
21802 (char *) "self",(char *) "tz", NULL
21803 };
21804
21805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21807 if (SWIG_arg_fail(1)) SWIG_fail;
21808 if (obj1) {
21809 {
21810 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21811 temp2 = true;
21812 }
21813 }
21814 {
21815 PyThreadState* __tstate = wxPyBeginAllowThreads();
21816 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21817
21818 wxPyEndAllowThreads(__tstate);
21819 if (PyErr_Occurred()) SWIG_fail;
21820 }
21821 {
21822 resultobj = SWIG_From_int((int)(result));
21823 }
21824 {
21825 if (temp2) delete arg2;
21826 }
21827 return resultobj;
21828 fail:
21829 {
21830 if (temp2) delete arg2;
21831 }
21832 return NULL;
21833 }
21834
21835
21836 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21837 PyObject *resultobj;
21838 wxDateTime *arg1 = (wxDateTime *) 0 ;
21839 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21840 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21841 int result;
21842 bool temp2 = false ;
21843 PyObject * obj0 = 0 ;
21844 PyObject * obj1 = 0 ;
21845 char *kwnames[] = {
21846 (char *) "self",(char *) "tz", NULL
21847 };
21848
21849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21851 if (SWIG_arg_fail(1)) SWIG_fail;
21852 if (obj1) {
21853 {
21854 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21855 temp2 = true;
21856 }
21857 }
21858 {
21859 PyThreadState* __tstate = wxPyBeginAllowThreads();
21860 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21861
21862 wxPyEndAllowThreads(__tstate);
21863 if (PyErr_Occurred()) SWIG_fail;
21864 }
21865 {
21866 resultobj = SWIG_From_int((int)(result));
21867 }
21868 {
21869 if (temp2) delete arg2;
21870 }
21871 return resultobj;
21872 fail:
21873 {
21874 if (temp2) delete arg2;
21875 }
21876 return NULL;
21877 }
21878
21879
21880 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21881 PyObject *resultobj;
21882 wxDateTime *arg1 = (wxDateTime *) 0 ;
21883 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21884 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21885 int result;
21886 bool temp2 = false ;
21887 PyObject * obj0 = 0 ;
21888 PyObject * obj1 = 0 ;
21889 char *kwnames[] = {
21890 (char *) "self",(char *) "tz", NULL
21891 };
21892
21893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21895 if (SWIG_arg_fail(1)) SWIG_fail;
21896 if (obj1) {
21897 {
21898 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21899 temp2 = true;
21900 }
21901 }
21902 {
21903 PyThreadState* __tstate = wxPyBeginAllowThreads();
21904 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21905
21906 wxPyEndAllowThreads(__tstate);
21907 if (PyErr_Occurred()) SWIG_fail;
21908 }
21909 {
21910 resultobj = SWIG_From_int((int)(result));
21911 }
21912 {
21913 if (temp2) delete arg2;
21914 }
21915 return resultobj;
21916 fail:
21917 {
21918 if (temp2) delete arg2;
21919 }
21920 return NULL;
21921 }
21922
21923
21924 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21925 PyObject *resultobj;
21926 wxDateTime *arg1 = (wxDateTime *) 0 ;
21927 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21928 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21929 int result;
21930 bool temp2 = false ;
21931 PyObject * obj0 = 0 ;
21932 PyObject * obj1 = 0 ;
21933 char *kwnames[] = {
21934 (char *) "self",(char *) "tz", NULL
21935 };
21936
21937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21939 if (SWIG_arg_fail(1)) SWIG_fail;
21940 if (obj1) {
21941 {
21942 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21943 temp2 = true;
21944 }
21945 }
21946 {
21947 PyThreadState* __tstate = wxPyBeginAllowThreads();
21948 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21949
21950 wxPyEndAllowThreads(__tstate);
21951 if (PyErr_Occurred()) SWIG_fail;
21952 }
21953 {
21954 resultobj = SWIG_From_int((int)(result));
21955 }
21956 {
21957 if (temp2) delete arg2;
21958 }
21959 return resultobj;
21960 fail:
21961 {
21962 if (temp2) delete arg2;
21963 }
21964 return NULL;
21965 }
21966
21967
21968 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21969 PyObject *resultobj;
21970 wxDateTime *arg1 = (wxDateTime *) 0 ;
21971 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21972 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21973 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21974 int result;
21975 bool temp3 = false ;
21976 PyObject * obj0 = 0 ;
21977 PyObject * obj1 = 0 ;
21978 PyObject * obj2 = 0 ;
21979 char *kwnames[] = {
21980 (char *) "self",(char *) "flags",(char *) "tz", NULL
21981 };
21982
21983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21985 if (SWIG_arg_fail(1)) SWIG_fail;
21986 if (obj1) {
21987 {
21988 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21989 if (SWIG_arg_fail(2)) SWIG_fail;
21990 }
21991 }
21992 if (obj2) {
21993 {
21994 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21995 temp3 = true;
21996 }
21997 }
21998 {
21999 PyThreadState* __tstate = wxPyBeginAllowThreads();
22000 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22001
22002 wxPyEndAllowThreads(__tstate);
22003 if (PyErr_Occurred()) SWIG_fail;
22004 }
22005 {
22006 resultobj = SWIG_From_int((int)(result));
22007 }
22008 {
22009 if (temp3) delete arg3;
22010 }
22011 return resultobj;
22012 fail:
22013 {
22014 if (temp3) delete arg3;
22015 }
22016 return NULL;
22017 }
22018
22019
22020 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22021 PyObject *resultobj;
22022 wxDateTime *arg1 = (wxDateTime *) 0 ;
22023 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22024 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22025 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22026 int result;
22027 bool temp3 = false ;
22028 PyObject * obj0 = 0 ;
22029 PyObject * obj1 = 0 ;
22030 PyObject * obj2 = 0 ;
22031 char *kwnames[] = {
22032 (char *) "self",(char *) "flags",(char *) "tz", NULL
22033 };
22034
22035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
22036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22037 if (SWIG_arg_fail(1)) SWIG_fail;
22038 if (obj1) {
22039 {
22040 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22041 if (SWIG_arg_fail(2)) SWIG_fail;
22042 }
22043 }
22044 if (obj2) {
22045 {
22046 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22047 temp3 = true;
22048 }
22049 }
22050 {
22051 PyThreadState* __tstate = wxPyBeginAllowThreads();
22052 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22053
22054 wxPyEndAllowThreads(__tstate);
22055 if (PyErr_Occurred()) SWIG_fail;
22056 }
22057 {
22058 resultobj = SWIG_From_int((int)(result));
22059 }
22060 {
22061 if (temp3) delete arg3;
22062 }
22063 return resultobj;
22064 fail:
22065 {
22066 if (temp3) delete arg3;
22067 }
22068 return NULL;
22069 }
22070
22071
22072 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22073 PyObject *resultobj;
22074 wxDateTime *arg1 = (wxDateTime *) 0 ;
22075 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22076 bool result;
22077 PyObject * obj0 = 0 ;
22078 PyObject * obj1 = 0 ;
22079 char *kwnames[] = {
22080 (char *) "self",(char *) "country", NULL
22081 };
22082
22083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22085 if (SWIG_arg_fail(1)) SWIG_fail;
22086 if (obj1) {
22087 {
22088 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22089 if (SWIG_arg_fail(2)) SWIG_fail;
22090 }
22091 }
22092 {
22093 PyThreadState* __tstate = wxPyBeginAllowThreads();
22094 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22095
22096 wxPyEndAllowThreads(__tstate);
22097 if (PyErr_Occurred()) SWIG_fail;
22098 }
22099 {
22100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22101 }
22102 return resultobj;
22103 fail:
22104 return NULL;
22105 }
22106
22107
22108 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22109 PyObject *resultobj;
22110 wxDateTime *arg1 = (wxDateTime *) 0 ;
22111 wxDateTime *arg2 = 0 ;
22112 bool result;
22113 PyObject * obj0 = 0 ;
22114 PyObject * obj1 = 0 ;
22115 char *kwnames[] = {
22116 (char *) "self",(char *) "datetime", NULL
22117 };
22118
22119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22121 if (SWIG_arg_fail(1)) SWIG_fail;
22122 {
22123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22124 if (SWIG_arg_fail(2)) SWIG_fail;
22125 if (arg2 == NULL) {
22126 SWIG_null_ref("wxDateTime");
22127 }
22128 if (SWIG_arg_fail(2)) SWIG_fail;
22129 }
22130 {
22131 PyThreadState* __tstate = wxPyBeginAllowThreads();
22132 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22133
22134 wxPyEndAllowThreads(__tstate);
22135 if (PyErr_Occurred()) SWIG_fail;
22136 }
22137 {
22138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22139 }
22140 return resultobj;
22141 fail:
22142 return NULL;
22143 }
22144
22145
22146 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22147 PyObject *resultobj;
22148 wxDateTime *arg1 = (wxDateTime *) 0 ;
22149 wxDateTime *arg2 = 0 ;
22150 bool result;
22151 PyObject * obj0 = 0 ;
22152 PyObject * obj1 = 0 ;
22153 char *kwnames[] = {
22154 (char *) "self",(char *) "datetime", NULL
22155 };
22156
22157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22159 if (SWIG_arg_fail(1)) SWIG_fail;
22160 {
22161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22162 if (SWIG_arg_fail(2)) SWIG_fail;
22163 if (arg2 == NULL) {
22164 SWIG_null_ref("wxDateTime");
22165 }
22166 if (SWIG_arg_fail(2)) SWIG_fail;
22167 }
22168 {
22169 PyThreadState* __tstate = wxPyBeginAllowThreads();
22170 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22171
22172 wxPyEndAllowThreads(__tstate);
22173 if (PyErr_Occurred()) SWIG_fail;
22174 }
22175 {
22176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22177 }
22178 return resultobj;
22179 fail:
22180 return NULL;
22181 }
22182
22183
22184 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22185 PyObject *resultobj;
22186 wxDateTime *arg1 = (wxDateTime *) 0 ;
22187 wxDateTime *arg2 = 0 ;
22188 bool result;
22189 PyObject * obj0 = 0 ;
22190 PyObject * obj1 = 0 ;
22191 char *kwnames[] = {
22192 (char *) "self",(char *) "datetime", NULL
22193 };
22194
22195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22197 if (SWIG_arg_fail(1)) SWIG_fail;
22198 {
22199 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22200 if (SWIG_arg_fail(2)) SWIG_fail;
22201 if (arg2 == NULL) {
22202 SWIG_null_ref("wxDateTime");
22203 }
22204 if (SWIG_arg_fail(2)) SWIG_fail;
22205 }
22206 {
22207 PyThreadState* __tstate = wxPyBeginAllowThreads();
22208 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22209
22210 wxPyEndAllowThreads(__tstate);
22211 if (PyErr_Occurred()) SWIG_fail;
22212 }
22213 {
22214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22215 }
22216 return resultobj;
22217 fail:
22218 return NULL;
22219 }
22220
22221
22222 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22223 PyObject *resultobj;
22224 wxDateTime *arg1 = (wxDateTime *) 0 ;
22225 wxDateTime *arg2 = 0 ;
22226 wxDateTime *arg3 = 0 ;
22227 bool result;
22228 PyObject * obj0 = 0 ;
22229 PyObject * obj1 = 0 ;
22230 PyObject * obj2 = 0 ;
22231 char *kwnames[] = {
22232 (char *) "self",(char *) "t1",(char *) "t2", NULL
22233 };
22234
22235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22237 if (SWIG_arg_fail(1)) SWIG_fail;
22238 {
22239 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22240 if (SWIG_arg_fail(2)) SWIG_fail;
22241 if (arg2 == NULL) {
22242 SWIG_null_ref("wxDateTime");
22243 }
22244 if (SWIG_arg_fail(2)) SWIG_fail;
22245 }
22246 {
22247 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22248 if (SWIG_arg_fail(3)) SWIG_fail;
22249 if (arg3 == NULL) {
22250 SWIG_null_ref("wxDateTime");
22251 }
22252 if (SWIG_arg_fail(3)) SWIG_fail;
22253 }
22254 {
22255 PyThreadState* __tstate = wxPyBeginAllowThreads();
22256 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22257
22258 wxPyEndAllowThreads(__tstate);
22259 if (PyErr_Occurred()) SWIG_fail;
22260 }
22261 {
22262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22263 }
22264 return resultobj;
22265 fail:
22266 return NULL;
22267 }
22268
22269
22270 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22271 PyObject *resultobj;
22272 wxDateTime *arg1 = (wxDateTime *) 0 ;
22273 wxDateTime *arg2 = 0 ;
22274 wxDateTime *arg3 = 0 ;
22275 bool result;
22276 PyObject * obj0 = 0 ;
22277 PyObject * obj1 = 0 ;
22278 PyObject * obj2 = 0 ;
22279 char *kwnames[] = {
22280 (char *) "self",(char *) "t1",(char *) "t2", NULL
22281 };
22282
22283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22285 if (SWIG_arg_fail(1)) SWIG_fail;
22286 {
22287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22288 if (SWIG_arg_fail(2)) SWIG_fail;
22289 if (arg2 == NULL) {
22290 SWIG_null_ref("wxDateTime");
22291 }
22292 if (SWIG_arg_fail(2)) SWIG_fail;
22293 }
22294 {
22295 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22296 if (SWIG_arg_fail(3)) SWIG_fail;
22297 if (arg3 == NULL) {
22298 SWIG_null_ref("wxDateTime");
22299 }
22300 if (SWIG_arg_fail(3)) SWIG_fail;
22301 }
22302 {
22303 PyThreadState* __tstate = wxPyBeginAllowThreads();
22304 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22305
22306 wxPyEndAllowThreads(__tstate);
22307 if (PyErr_Occurred()) SWIG_fail;
22308 }
22309 {
22310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22311 }
22312 return resultobj;
22313 fail:
22314 return NULL;
22315 }
22316
22317
22318 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22319 PyObject *resultobj;
22320 wxDateTime *arg1 = (wxDateTime *) 0 ;
22321 wxDateTime *arg2 = 0 ;
22322 bool result;
22323 PyObject * obj0 = 0 ;
22324 PyObject * obj1 = 0 ;
22325 char *kwnames[] = {
22326 (char *) "self",(char *) "dt", NULL
22327 };
22328
22329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22331 if (SWIG_arg_fail(1)) SWIG_fail;
22332 {
22333 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22334 if (SWIG_arg_fail(2)) SWIG_fail;
22335 if (arg2 == NULL) {
22336 SWIG_null_ref("wxDateTime");
22337 }
22338 if (SWIG_arg_fail(2)) SWIG_fail;
22339 }
22340 {
22341 PyThreadState* __tstate = wxPyBeginAllowThreads();
22342 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22343
22344 wxPyEndAllowThreads(__tstate);
22345 if (PyErr_Occurred()) SWIG_fail;
22346 }
22347 {
22348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22349 }
22350 return resultobj;
22351 fail:
22352 return NULL;
22353 }
22354
22355
22356 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22357 PyObject *resultobj;
22358 wxDateTime *arg1 = (wxDateTime *) 0 ;
22359 wxDateTime *arg2 = 0 ;
22360 bool result;
22361 PyObject * obj0 = 0 ;
22362 PyObject * obj1 = 0 ;
22363 char *kwnames[] = {
22364 (char *) "self",(char *) "dt", NULL
22365 };
22366
22367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22369 if (SWIG_arg_fail(1)) SWIG_fail;
22370 {
22371 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22372 if (SWIG_arg_fail(2)) SWIG_fail;
22373 if (arg2 == NULL) {
22374 SWIG_null_ref("wxDateTime");
22375 }
22376 if (SWIG_arg_fail(2)) SWIG_fail;
22377 }
22378 {
22379 PyThreadState* __tstate = wxPyBeginAllowThreads();
22380 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22381
22382 wxPyEndAllowThreads(__tstate);
22383 if (PyErr_Occurred()) SWIG_fail;
22384 }
22385 {
22386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22387 }
22388 return resultobj;
22389 fail:
22390 return NULL;
22391 }
22392
22393
22394 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22395 PyObject *resultobj;
22396 wxDateTime *arg1 = (wxDateTime *) 0 ;
22397 wxDateTime *arg2 = 0 ;
22398 wxTimeSpan *arg3 = 0 ;
22399 bool result;
22400 PyObject * obj0 = 0 ;
22401 PyObject * obj1 = 0 ;
22402 PyObject * obj2 = 0 ;
22403 char *kwnames[] = {
22404 (char *) "self",(char *) "dt",(char *) "ts", NULL
22405 };
22406
22407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22409 if (SWIG_arg_fail(1)) SWIG_fail;
22410 {
22411 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22412 if (SWIG_arg_fail(2)) SWIG_fail;
22413 if (arg2 == NULL) {
22414 SWIG_null_ref("wxDateTime");
22415 }
22416 if (SWIG_arg_fail(2)) SWIG_fail;
22417 }
22418 {
22419 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22420 if (SWIG_arg_fail(3)) SWIG_fail;
22421 if (arg3 == NULL) {
22422 SWIG_null_ref("wxTimeSpan");
22423 }
22424 if (SWIG_arg_fail(3)) SWIG_fail;
22425 }
22426 {
22427 PyThreadState* __tstate = wxPyBeginAllowThreads();
22428 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22429
22430 wxPyEndAllowThreads(__tstate);
22431 if (PyErr_Occurred()) SWIG_fail;
22432 }
22433 {
22434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22435 }
22436 return resultobj;
22437 fail:
22438 return NULL;
22439 }
22440
22441
22442 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22443 PyObject *resultobj;
22444 wxDateTime *arg1 = (wxDateTime *) 0 ;
22445 wxTimeSpan *arg2 = 0 ;
22446 wxDateTime *result;
22447 PyObject * obj0 = 0 ;
22448 PyObject * obj1 = 0 ;
22449 char *kwnames[] = {
22450 (char *) "self",(char *) "diff", NULL
22451 };
22452
22453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22455 if (SWIG_arg_fail(1)) SWIG_fail;
22456 {
22457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22458 if (SWIG_arg_fail(2)) SWIG_fail;
22459 if (arg2 == NULL) {
22460 SWIG_null_ref("wxTimeSpan");
22461 }
22462 if (SWIG_arg_fail(2)) SWIG_fail;
22463 }
22464 {
22465 PyThreadState* __tstate = wxPyBeginAllowThreads();
22466 {
22467 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22468 result = (wxDateTime *) &_result_ref;
22469 }
22470
22471 wxPyEndAllowThreads(__tstate);
22472 if (PyErr_Occurred()) SWIG_fail;
22473 }
22474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22475 return resultobj;
22476 fail:
22477 return NULL;
22478 }
22479
22480
22481 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22482 PyObject *resultobj;
22483 wxDateTime *arg1 = (wxDateTime *) 0 ;
22484 wxDateSpan *arg2 = 0 ;
22485 wxDateTime *result;
22486 PyObject * obj0 = 0 ;
22487 PyObject * obj1 = 0 ;
22488 char *kwnames[] = {
22489 (char *) "self",(char *) "diff", NULL
22490 };
22491
22492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22494 if (SWIG_arg_fail(1)) SWIG_fail;
22495 {
22496 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22497 if (SWIG_arg_fail(2)) SWIG_fail;
22498 if (arg2 == NULL) {
22499 SWIG_null_ref("wxDateSpan");
22500 }
22501 if (SWIG_arg_fail(2)) SWIG_fail;
22502 }
22503 {
22504 PyThreadState* __tstate = wxPyBeginAllowThreads();
22505 {
22506 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22507 result = (wxDateTime *) &_result_ref;
22508 }
22509
22510 wxPyEndAllowThreads(__tstate);
22511 if (PyErr_Occurred()) SWIG_fail;
22512 }
22513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22514 return resultobj;
22515 fail:
22516 return NULL;
22517 }
22518
22519
22520 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22521 PyObject *resultobj;
22522 wxDateTime *arg1 = (wxDateTime *) 0 ;
22523 wxTimeSpan *arg2 = 0 ;
22524 wxDateTime *result;
22525 PyObject * obj0 = 0 ;
22526 PyObject * obj1 = 0 ;
22527 char *kwnames[] = {
22528 (char *) "self",(char *) "diff", NULL
22529 };
22530
22531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22533 if (SWIG_arg_fail(1)) SWIG_fail;
22534 {
22535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22536 if (SWIG_arg_fail(2)) SWIG_fail;
22537 if (arg2 == NULL) {
22538 SWIG_null_ref("wxTimeSpan");
22539 }
22540 if (SWIG_arg_fail(2)) SWIG_fail;
22541 }
22542 {
22543 PyThreadState* __tstate = wxPyBeginAllowThreads();
22544 {
22545 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22546 result = (wxDateTime *) &_result_ref;
22547 }
22548
22549 wxPyEndAllowThreads(__tstate);
22550 if (PyErr_Occurred()) SWIG_fail;
22551 }
22552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22553 return resultobj;
22554 fail:
22555 return NULL;
22556 }
22557
22558
22559 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22560 PyObject *resultobj;
22561 wxDateTime *arg1 = (wxDateTime *) 0 ;
22562 wxDateSpan *arg2 = 0 ;
22563 wxDateTime *result;
22564 PyObject * obj0 = 0 ;
22565 PyObject * obj1 = 0 ;
22566 char *kwnames[] = {
22567 (char *) "self",(char *) "diff", NULL
22568 };
22569
22570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22572 if (SWIG_arg_fail(1)) SWIG_fail;
22573 {
22574 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22575 if (SWIG_arg_fail(2)) SWIG_fail;
22576 if (arg2 == NULL) {
22577 SWIG_null_ref("wxDateSpan");
22578 }
22579 if (SWIG_arg_fail(2)) SWIG_fail;
22580 }
22581 {
22582 PyThreadState* __tstate = wxPyBeginAllowThreads();
22583 {
22584 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22585 result = (wxDateTime *) &_result_ref;
22586 }
22587
22588 wxPyEndAllowThreads(__tstate);
22589 if (PyErr_Occurred()) SWIG_fail;
22590 }
22591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22592 return resultobj;
22593 fail:
22594 return NULL;
22595 }
22596
22597
22598 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22599 PyObject *resultobj;
22600 wxDateTime *arg1 = (wxDateTime *) 0 ;
22601 wxDateTime *arg2 = 0 ;
22602 wxTimeSpan result;
22603 PyObject * obj0 = 0 ;
22604 PyObject * obj1 = 0 ;
22605 char *kwnames[] = {
22606 (char *) "self",(char *) "dt", NULL
22607 };
22608
22609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22611 if (SWIG_arg_fail(1)) SWIG_fail;
22612 {
22613 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22614 if (SWIG_arg_fail(2)) SWIG_fail;
22615 if (arg2 == NULL) {
22616 SWIG_null_ref("wxDateTime");
22617 }
22618 if (SWIG_arg_fail(2)) SWIG_fail;
22619 }
22620 {
22621 PyThreadState* __tstate = wxPyBeginAllowThreads();
22622 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22623
22624 wxPyEndAllowThreads(__tstate);
22625 if (PyErr_Occurred()) SWIG_fail;
22626 }
22627 {
22628 wxTimeSpan * resultptr;
22629 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22630 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22631 }
22632 return resultobj;
22633 fail:
22634 return NULL;
22635 }
22636
22637
22638 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22639 PyObject *resultobj;
22640 wxDateTime *arg1 = (wxDateTime *) 0 ;
22641 wxTimeSpan *arg2 = 0 ;
22642 wxDateTime *result;
22643 PyObject * obj0 = 0 ;
22644 PyObject * obj1 = 0 ;
22645
22646 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22648 if (SWIG_arg_fail(1)) SWIG_fail;
22649 {
22650 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22651 if (SWIG_arg_fail(2)) SWIG_fail;
22652 if (arg2 == NULL) {
22653 SWIG_null_ref("wxTimeSpan");
22654 }
22655 if (SWIG_arg_fail(2)) SWIG_fail;
22656 }
22657 {
22658 PyThreadState* __tstate = wxPyBeginAllowThreads();
22659 {
22660 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22661 result = (wxDateTime *) &_result_ref;
22662 }
22663
22664 wxPyEndAllowThreads(__tstate);
22665 if (PyErr_Occurred()) SWIG_fail;
22666 }
22667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22668 return resultobj;
22669 fail:
22670 return NULL;
22671 }
22672
22673
22674 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22675 PyObject *resultobj;
22676 wxDateTime *arg1 = (wxDateTime *) 0 ;
22677 wxDateSpan *arg2 = 0 ;
22678 wxDateTime *result;
22679 PyObject * obj0 = 0 ;
22680 PyObject * obj1 = 0 ;
22681
22682 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22684 if (SWIG_arg_fail(1)) SWIG_fail;
22685 {
22686 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22687 if (SWIG_arg_fail(2)) SWIG_fail;
22688 if (arg2 == NULL) {
22689 SWIG_null_ref("wxDateSpan");
22690 }
22691 if (SWIG_arg_fail(2)) SWIG_fail;
22692 }
22693 {
22694 PyThreadState* __tstate = wxPyBeginAllowThreads();
22695 {
22696 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22697 result = (wxDateTime *) &_result_ref;
22698 }
22699
22700 wxPyEndAllowThreads(__tstate);
22701 if (PyErr_Occurred()) SWIG_fail;
22702 }
22703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22704 return resultobj;
22705 fail:
22706 return NULL;
22707 }
22708
22709
22710 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22711 int argc;
22712 PyObject *argv[3];
22713 int ii;
22714
22715 argc = PyObject_Length(args);
22716 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22717 argv[ii] = PyTuple_GetItem(args,ii);
22718 }
22719 if (argc == 2) {
22720 int _v;
22721 {
22722 void *ptr;
22723 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22724 _v = 0;
22725 PyErr_Clear();
22726 } else {
22727 _v = 1;
22728 }
22729 }
22730 if (_v) {
22731 {
22732 void *ptr = 0;
22733 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22734 _v = 0;
22735 PyErr_Clear();
22736 } else {
22737 _v = (ptr != 0);
22738 }
22739 }
22740 if (_v) {
22741 return _wrap_DateTime___iadd____SWIG_0(self,args);
22742 }
22743 }
22744 }
22745 if (argc == 2) {
22746 int _v;
22747 {
22748 void *ptr;
22749 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22750 _v = 0;
22751 PyErr_Clear();
22752 } else {
22753 _v = 1;
22754 }
22755 }
22756 if (_v) {
22757 {
22758 void *ptr = 0;
22759 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22760 _v = 0;
22761 PyErr_Clear();
22762 } else {
22763 _v = (ptr != 0);
22764 }
22765 }
22766 if (_v) {
22767 return _wrap_DateTime___iadd____SWIG_1(self,args);
22768 }
22769 }
22770 }
22771
22772 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22773 return NULL;
22774 }
22775
22776
22777 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22778 PyObject *resultobj;
22779 wxDateTime *arg1 = (wxDateTime *) 0 ;
22780 wxTimeSpan *arg2 = 0 ;
22781 wxDateTime *result;
22782 PyObject * obj0 = 0 ;
22783 PyObject * obj1 = 0 ;
22784
22785 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22787 if (SWIG_arg_fail(1)) SWIG_fail;
22788 {
22789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22790 if (SWIG_arg_fail(2)) SWIG_fail;
22791 if (arg2 == NULL) {
22792 SWIG_null_ref("wxTimeSpan");
22793 }
22794 if (SWIG_arg_fail(2)) SWIG_fail;
22795 }
22796 {
22797 PyThreadState* __tstate = wxPyBeginAllowThreads();
22798 {
22799 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22800 result = (wxDateTime *) &_result_ref;
22801 }
22802
22803 wxPyEndAllowThreads(__tstate);
22804 if (PyErr_Occurred()) SWIG_fail;
22805 }
22806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22807 return resultobj;
22808 fail:
22809 return NULL;
22810 }
22811
22812
22813 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22814 PyObject *resultobj;
22815 wxDateTime *arg1 = (wxDateTime *) 0 ;
22816 wxDateSpan *arg2 = 0 ;
22817 wxDateTime *result;
22818 PyObject * obj0 = 0 ;
22819 PyObject * obj1 = 0 ;
22820
22821 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22823 if (SWIG_arg_fail(1)) SWIG_fail;
22824 {
22825 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22826 if (SWIG_arg_fail(2)) SWIG_fail;
22827 if (arg2 == NULL) {
22828 SWIG_null_ref("wxDateSpan");
22829 }
22830 if (SWIG_arg_fail(2)) SWIG_fail;
22831 }
22832 {
22833 PyThreadState* __tstate = wxPyBeginAllowThreads();
22834 {
22835 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22836 result = (wxDateTime *) &_result_ref;
22837 }
22838
22839 wxPyEndAllowThreads(__tstate);
22840 if (PyErr_Occurred()) SWIG_fail;
22841 }
22842 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22843 return resultobj;
22844 fail:
22845 return NULL;
22846 }
22847
22848
22849 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22850 int argc;
22851 PyObject *argv[3];
22852 int ii;
22853
22854 argc = PyObject_Length(args);
22855 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22856 argv[ii] = PyTuple_GetItem(args,ii);
22857 }
22858 if (argc == 2) {
22859 int _v;
22860 {
22861 void *ptr;
22862 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22863 _v = 0;
22864 PyErr_Clear();
22865 } else {
22866 _v = 1;
22867 }
22868 }
22869 if (_v) {
22870 {
22871 void *ptr = 0;
22872 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22873 _v = 0;
22874 PyErr_Clear();
22875 } else {
22876 _v = (ptr != 0);
22877 }
22878 }
22879 if (_v) {
22880 return _wrap_DateTime___isub____SWIG_0(self,args);
22881 }
22882 }
22883 }
22884 if (argc == 2) {
22885 int _v;
22886 {
22887 void *ptr;
22888 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22889 _v = 0;
22890 PyErr_Clear();
22891 } else {
22892 _v = 1;
22893 }
22894 }
22895 if (_v) {
22896 {
22897 void *ptr = 0;
22898 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22899 _v = 0;
22900 PyErr_Clear();
22901 } else {
22902 _v = (ptr != 0);
22903 }
22904 }
22905 if (_v) {
22906 return _wrap_DateTime___isub____SWIG_1(self,args);
22907 }
22908 }
22909 }
22910
22911 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22912 return NULL;
22913 }
22914
22915
22916 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22917 PyObject *resultobj;
22918 wxDateTime *arg1 = (wxDateTime *) 0 ;
22919 wxTimeSpan *arg2 = 0 ;
22920 wxDateTime result;
22921 PyObject * obj0 = 0 ;
22922 PyObject * obj1 = 0 ;
22923
22924 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22926 if (SWIG_arg_fail(1)) SWIG_fail;
22927 {
22928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22929 if (SWIG_arg_fail(2)) SWIG_fail;
22930 if (arg2 == NULL) {
22931 SWIG_null_ref("wxTimeSpan");
22932 }
22933 if (SWIG_arg_fail(2)) SWIG_fail;
22934 }
22935 {
22936 PyThreadState* __tstate = wxPyBeginAllowThreads();
22937 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22938
22939 wxPyEndAllowThreads(__tstate);
22940 if (PyErr_Occurred()) SWIG_fail;
22941 }
22942 {
22943 wxDateTime * resultptr;
22944 resultptr = new wxDateTime((wxDateTime &)(result));
22945 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22946 }
22947 return resultobj;
22948 fail:
22949 return NULL;
22950 }
22951
22952
22953 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22954 PyObject *resultobj;
22955 wxDateTime *arg1 = (wxDateTime *) 0 ;
22956 wxDateSpan *arg2 = 0 ;
22957 wxDateTime result;
22958 PyObject * obj0 = 0 ;
22959 PyObject * obj1 = 0 ;
22960
22961 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22963 if (SWIG_arg_fail(1)) SWIG_fail;
22964 {
22965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22966 if (SWIG_arg_fail(2)) SWIG_fail;
22967 if (arg2 == NULL) {
22968 SWIG_null_ref("wxDateSpan");
22969 }
22970 if (SWIG_arg_fail(2)) SWIG_fail;
22971 }
22972 {
22973 PyThreadState* __tstate = wxPyBeginAllowThreads();
22974 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22975
22976 wxPyEndAllowThreads(__tstate);
22977 if (PyErr_Occurred()) SWIG_fail;
22978 }
22979 {
22980 wxDateTime * resultptr;
22981 resultptr = new wxDateTime((wxDateTime &)(result));
22982 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22983 }
22984 return resultobj;
22985 fail:
22986 return NULL;
22987 }
22988
22989
22990 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22991 int argc;
22992 PyObject *argv[3];
22993 int ii;
22994
22995 argc = PyObject_Length(args);
22996 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22997 argv[ii] = PyTuple_GetItem(args,ii);
22998 }
22999 if (argc == 2) {
23000 int _v;
23001 {
23002 void *ptr;
23003 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23004 _v = 0;
23005 PyErr_Clear();
23006 } else {
23007 _v = 1;
23008 }
23009 }
23010 if (_v) {
23011 {
23012 void *ptr = 0;
23013 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23014 _v = 0;
23015 PyErr_Clear();
23016 } else {
23017 _v = (ptr != 0);
23018 }
23019 }
23020 if (_v) {
23021 return _wrap_DateTime___add____SWIG_0(self,args);
23022 }
23023 }
23024 }
23025 if (argc == 2) {
23026 int _v;
23027 {
23028 void *ptr;
23029 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23030 _v = 0;
23031 PyErr_Clear();
23032 } else {
23033 _v = 1;
23034 }
23035 }
23036 if (_v) {
23037 {
23038 void *ptr = 0;
23039 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23040 _v = 0;
23041 PyErr_Clear();
23042 } else {
23043 _v = (ptr != 0);
23044 }
23045 }
23046 if (_v) {
23047 return _wrap_DateTime___add____SWIG_1(self,args);
23048 }
23049 }
23050 }
23051
23052 Py_INCREF(Py_NotImplemented);
23053 return Py_NotImplemented;
23054 }
23055
23056
23057 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23058 PyObject *resultobj;
23059 wxDateTime *arg1 = (wxDateTime *) 0 ;
23060 wxDateTime *arg2 = 0 ;
23061 wxTimeSpan result;
23062 PyObject * obj0 = 0 ;
23063 PyObject * obj1 = 0 ;
23064
23065 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23067 if (SWIG_arg_fail(1)) SWIG_fail;
23068 {
23069 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23070 if (SWIG_arg_fail(2)) SWIG_fail;
23071 if (arg2 == NULL) {
23072 SWIG_null_ref("wxDateTime");
23073 }
23074 if (SWIG_arg_fail(2)) SWIG_fail;
23075 }
23076 {
23077 PyThreadState* __tstate = wxPyBeginAllowThreads();
23078 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23079
23080 wxPyEndAllowThreads(__tstate);
23081 if (PyErr_Occurred()) SWIG_fail;
23082 }
23083 {
23084 wxTimeSpan * resultptr;
23085 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23086 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23087 }
23088 return resultobj;
23089 fail:
23090 return NULL;
23091 }
23092
23093
23094 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23095 PyObject *resultobj;
23096 wxDateTime *arg1 = (wxDateTime *) 0 ;
23097 wxTimeSpan *arg2 = 0 ;
23098 wxDateTime result;
23099 PyObject * obj0 = 0 ;
23100 PyObject * obj1 = 0 ;
23101
23102 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23104 if (SWIG_arg_fail(1)) SWIG_fail;
23105 {
23106 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23107 if (SWIG_arg_fail(2)) SWIG_fail;
23108 if (arg2 == NULL) {
23109 SWIG_null_ref("wxTimeSpan");
23110 }
23111 if (SWIG_arg_fail(2)) SWIG_fail;
23112 }
23113 {
23114 PyThreadState* __tstate = wxPyBeginAllowThreads();
23115 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23116
23117 wxPyEndAllowThreads(__tstate);
23118 if (PyErr_Occurred()) SWIG_fail;
23119 }
23120 {
23121 wxDateTime * resultptr;
23122 resultptr = new wxDateTime((wxDateTime &)(result));
23123 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23124 }
23125 return resultobj;
23126 fail:
23127 return NULL;
23128 }
23129
23130
23131 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23132 PyObject *resultobj;
23133 wxDateTime *arg1 = (wxDateTime *) 0 ;
23134 wxDateSpan *arg2 = 0 ;
23135 wxDateTime result;
23136 PyObject * obj0 = 0 ;
23137 PyObject * obj1 = 0 ;
23138
23139 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23141 if (SWIG_arg_fail(1)) SWIG_fail;
23142 {
23143 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23144 if (SWIG_arg_fail(2)) SWIG_fail;
23145 if (arg2 == NULL) {
23146 SWIG_null_ref("wxDateSpan");
23147 }
23148 if (SWIG_arg_fail(2)) SWIG_fail;
23149 }
23150 {
23151 PyThreadState* __tstate = wxPyBeginAllowThreads();
23152 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23153
23154 wxPyEndAllowThreads(__tstate);
23155 if (PyErr_Occurred()) SWIG_fail;
23156 }
23157 {
23158 wxDateTime * resultptr;
23159 resultptr = new wxDateTime((wxDateTime &)(result));
23160 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23161 }
23162 return resultobj;
23163 fail:
23164 return NULL;
23165 }
23166
23167
23168 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23169 int argc;
23170 PyObject *argv[3];
23171 int ii;
23172
23173 argc = PyObject_Length(args);
23174 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23175 argv[ii] = PyTuple_GetItem(args,ii);
23176 }
23177 if (argc == 2) {
23178 int _v;
23179 {
23180 void *ptr;
23181 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23182 _v = 0;
23183 PyErr_Clear();
23184 } else {
23185 _v = 1;
23186 }
23187 }
23188 if (_v) {
23189 {
23190 void *ptr = 0;
23191 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23192 _v = 0;
23193 PyErr_Clear();
23194 } else {
23195 _v = (ptr != 0);
23196 }
23197 }
23198 if (_v) {
23199 return _wrap_DateTime___sub____SWIG_0(self,args);
23200 }
23201 }
23202 }
23203 if (argc == 2) {
23204 int _v;
23205 {
23206 void *ptr;
23207 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23208 _v = 0;
23209 PyErr_Clear();
23210 } else {
23211 _v = 1;
23212 }
23213 }
23214 if (_v) {
23215 {
23216 void *ptr = 0;
23217 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23218 _v = 0;
23219 PyErr_Clear();
23220 } else {
23221 _v = (ptr != 0);
23222 }
23223 }
23224 if (_v) {
23225 return _wrap_DateTime___sub____SWIG_1(self,args);
23226 }
23227 }
23228 }
23229 if (argc == 2) {
23230 int _v;
23231 {
23232 void *ptr;
23233 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23234 _v = 0;
23235 PyErr_Clear();
23236 } else {
23237 _v = 1;
23238 }
23239 }
23240 if (_v) {
23241 {
23242 void *ptr = 0;
23243 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23244 _v = 0;
23245 PyErr_Clear();
23246 } else {
23247 _v = (ptr != 0);
23248 }
23249 }
23250 if (_v) {
23251 return _wrap_DateTime___sub____SWIG_2(self,args);
23252 }
23253 }
23254 }
23255
23256 Py_INCREF(Py_NotImplemented);
23257 return Py_NotImplemented;
23258 }
23259
23260
23261 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23262 PyObject *resultobj;
23263 wxDateTime *arg1 = (wxDateTime *) 0 ;
23264 wxDateTime *arg2 = (wxDateTime *) 0 ;
23265 bool result;
23266 PyObject * obj0 = 0 ;
23267 PyObject * obj1 = 0 ;
23268 char *kwnames[] = {
23269 (char *) "self",(char *) "other", NULL
23270 };
23271
23272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23274 if (SWIG_arg_fail(1)) SWIG_fail;
23275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23276 if (SWIG_arg_fail(2)) SWIG_fail;
23277 {
23278 PyThreadState* __tstate = wxPyBeginAllowThreads();
23279 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23280
23281 wxPyEndAllowThreads(__tstate);
23282 if (PyErr_Occurred()) SWIG_fail;
23283 }
23284 {
23285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23286 }
23287 return resultobj;
23288 fail:
23289 return NULL;
23290 }
23291
23292
23293 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23294 PyObject *resultobj;
23295 wxDateTime *arg1 = (wxDateTime *) 0 ;
23296 wxDateTime *arg2 = (wxDateTime *) 0 ;
23297 bool result;
23298 PyObject * obj0 = 0 ;
23299 PyObject * obj1 = 0 ;
23300 char *kwnames[] = {
23301 (char *) "self",(char *) "other", NULL
23302 };
23303
23304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23306 if (SWIG_arg_fail(1)) SWIG_fail;
23307 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23308 if (SWIG_arg_fail(2)) SWIG_fail;
23309 {
23310 PyThreadState* __tstate = wxPyBeginAllowThreads();
23311 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23312
23313 wxPyEndAllowThreads(__tstate);
23314 if (PyErr_Occurred()) SWIG_fail;
23315 }
23316 {
23317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23318 }
23319 return resultobj;
23320 fail:
23321 return NULL;
23322 }
23323
23324
23325 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23326 PyObject *resultobj;
23327 wxDateTime *arg1 = (wxDateTime *) 0 ;
23328 wxDateTime *arg2 = (wxDateTime *) 0 ;
23329 bool result;
23330 PyObject * obj0 = 0 ;
23331 PyObject * obj1 = 0 ;
23332 char *kwnames[] = {
23333 (char *) "self",(char *) "other", NULL
23334 };
23335
23336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23338 if (SWIG_arg_fail(1)) SWIG_fail;
23339 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23340 if (SWIG_arg_fail(2)) SWIG_fail;
23341 {
23342 PyThreadState* __tstate = wxPyBeginAllowThreads();
23343 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23344
23345 wxPyEndAllowThreads(__tstate);
23346 if (PyErr_Occurred()) SWIG_fail;
23347 }
23348 {
23349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23350 }
23351 return resultobj;
23352 fail:
23353 return NULL;
23354 }
23355
23356
23357 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23358 PyObject *resultobj;
23359 wxDateTime *arg1 = (wxDateTime *) 0 ;
23360 wxDateTime *arg2 = (wxDateTime *) 0 ;
23361 bool result;
23362 PyObject * obj0 = 0 ;
23363 PyObject * obj1 = 0 ;
23364 char *kwnames[] = {
23365 (char *) "self",(char *) "other", NULL
23366 };
23367
23368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23370 if (SWIG_arg_fail(1)) SWIG_fail;
23371 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23372 if (SWIG_arg_fail(2)) SWIG_fail;
23373 {
23374 PyThreadState* __tstate = wxPyBeginAllowThreads();
23375 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23376
23377 wxPyEndAllowThreads(__tstate);
23378 if (PyErr_Occurred()) SWIG_fail;
23379 }
23380 {
23381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23382 }
23383 return resultobj;
23384 fail:
23385 return NULL;
23386 }
23387
23388
23389 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23390 PyObject *resultobj;
23391 wxDateTime *arg1 = (wxDateTime *) 0 ;
23392 wxDateTime *arg2 = (wxDateTime *) 0 ;
23393 bool result;
23394 PyObject * obj0 = 0 ;
23395 PyObject * obj1 = 0 ;
23396 char *kwnames[] = {
23397 (char *) "self",(char *) "other", NULL
23398 };
23399
23400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23402 if (SWIG_arg_fail(1)) SWIG_fail;
23403 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23404 if (SWIG_arg_fail(2)) SWIG_fail;
23405 {
23406 PyThreadState* __tstate = wxPyBeginAllowThreads();
23407 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23408
23409 wxPyEndAllowThreads(__tstate);
23410 if (PyErr_Occurred()) SWIG_fail;
23411 }
23412 {
23413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23414 }
23415 return resultobj;
23416 fail:
23417 return NULL;
23418 }
23419
23420
23421 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23422 PyObject *resultobj;
23423 wxDateTime *arg1 = (wxDateTime *) 0 ;
23424 wxDateTime *arg2 = (wxDateTime *) 0 ;
23425 bool result;
23426 PyObject * obj0 = 0 ;
23427 PyObject * obj1 = 0 ;
23428 char *kwnames[] = {
23429 (char *) "self",(char *) "other", NULL
23430 };
23431
23432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23434 if (SWIG_arg_fail(1)) SWIG_fail;
23435 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23436 if (SWIG_arg_fail(2)) SWIG_fail;
23437 {
23438 PyThreadState* __tstate = wxPyBeginAllowThreads();
23439 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23440
23441 wxPyEndAllowThreads(__tstate);
23442 if (PyErr_Occurred()) SWIG_fail;
23443 }
23444 {
23445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23446 }
23447 return resultobj;
23448 fail:
23449 return NULL;
23450 }
23451
23452
23453 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23454 PyObject *resultobj;
23455 wxDateTime *arg1 = (wxDateTime *) 0 ;
23456 wxString *arg2 = 0 ;
23457 int result;
23458 bool temp2 = false ;
23459 PyObject * obj0 = 0 ;
23460 PyObject * obj1 = 0 ;
23461 char *kwnames[] = {
23462 (char *) "self",(char *) "date", NULL
23463 };
23464
23465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23467 if (SWIG_arg_fail(1)) SWIG_fail;
23468 {
23469 arg2 = wxString_in_helper(obj1);
23470 if (arg2 == NULL) SWIG_fail;
23471 temp2 = true;
23472 }
23473 {
23474 PyThreadState* __tstate = wxPyBeginAllowThreads();
23475 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23476
23477 wxPyEndAllowThreads(__tstate);
23478 if (PyErr_Occurred()) SWIG_fail;
23479 }
23480 {
23481 resultobj = SWIG_From_int((int)(result));
23482 }
23483 {
23484 if (temp2)
23485 delete arg2;
23486 }
23487 return resultobj;
23488 fail:
23489 {
23490 if (temp2)
23491 delete arg2;
23492 }
23493 return NULL;
23494 }
23495
23496
23497 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23498 PyObject *resultobj;
23499 wxDateTime *arg1 = (wxDateTime *) 0 ;
23500 wxString *arg2 = 0 ;
23501 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23502 wxString *arg3 = (wxString *) &arg3_defvalue ;
23503 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23504 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23505 int result;
23506 bool temp2 = false ;
23507 bool temp3 = false ;
23508 PyObject * obj0 = 0 ;
23509 PyObject * obj1 = 0 ;
23510 PyObject * obj2 = 0 ;
23511 PyObject * obj3 = 0 ;
23512 char *kwnames[] = {
23513 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23514 };
23515
23516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23518 if (SWIG_arg_fail(1)) SWIG_fail;
23519 {
23520 arg2 = wxString_in_helper(obj1);
23521 if (arg2 == NULL) SWIG_fail;
23522 temp2 = true;
23523 }
23524 if (obj2) {
23525 {
23526 arg3 = wxString_in_helper(obj2);
23527 if (arg3 == NULL) SWIG_fail;
23528 temp3 = true;
23529 }
23530 }
23531 if (obj3) {
23532 {
23533 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23534 if (SWIG_arg_fail(4)) SWIG_fail;
23535 if (arg4 == NULL) {
23536 SWIG_null_ref("wxDateTime");
23537 }
23538 if (SWIG_arg_fail(4)) SWIG_fail;
23539 }
23540 }
23541 {
23542 PyThreadState* __tstate = wxPyBeginAllowThreads();
23543 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23544
23545 wxPyEndAllowThreads(__tstate);
23546 if (PyErr_Occurred()) SWIG_fail;
23547 }
23548 {
23549 resultobj = SWIG_From_int((int)(result));
23550 }
23551 {
23552 if (temp2)
23553 delete arg2;
23554 }
23555 {
23556 if (temp3)
23557 delete arg3;
23558 }
23559 return resultobj;
23560 fail:
23561 {
23562 if (temp2)
23563 delete arg2;
23564 }
23565 {
23566 if (temp3)
23567 delete arg3;
23568 }
23569 return NULL;
23570 }
23571
23572
23573 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23574 PyObject *resultobj;
23575 wxDateTime *arg1 = (wxDateTime *) 0 ;
23576 wxString *arg2 = 0 ;
23577 int result;
23578 bool temp2 = false ;
23579 PyObject * obj0 = 0 ;
23580 PyObject * obj1 = 0 ;
23581 char *kwnames[] = {
23582 (char *) "self",(char *) "datetime", NULL
23583 };
23584
23585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23587 if (SWIG_arg_fail(1)) SWIG_fail;
23588 {
23589 arg2 = wxString_in_helper(obj1);
23590 if (arg2 == NULL) SWIG_fail;
23591 temp2 = true;
23592 }
23593 {
23594 PyThreadState* __tstate = wxPyBeginAllowThreads();
23595 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23596
23597 wxPyEndAllowThreads(__tstate);
23598 if (PyErr_Occurred()) SWIG_fail;
23599 }
23600 {
23601 resultobj = SWIG_From_int((int)(result));
23602 }
23603 {
23604 if (temp2)
23605 delete arg2;
23606 }
23607 return resultobj;
23608 fail:
23609 {
23610 if (temp2)
23611 delete arg2;
23612 }
23613 return NULL;
23614 }
23615
23616
23617 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23618 PyObject *resultobj;
23619 wxDateTime *arg1 = (wxDateTime *) 0 ;
23620 wxString *arg2 = 0 ;
23621 int result;
23622 bool temp2 = false ;
23623 PyObject * obj0 = 0 ;
23624 PyObject * obj1 = 0 ;
23625 char *kwnames[] = {
23626 (char *) "self",(char *) "date", NULL
23627 };
23628
23629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23631 if (SWIG_arg_fail(1)) SWIG_fail;
23632 {
23633 arg2 = wxString_in_helper(obj1);
23634 if (arg2 == NULL) SWIG_fail;
23635 temp2 = true;
23636 }
23637 {
23638 PyThreadState* __tstate = wxPyBeginAllowThreads();
23639 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23640
23641 wxPyEndAllowThreads(__tstate);
23642 if (PyErr_Occurred()) SWIG_fail;
23643 }
23644 {
23645 resultobj = SWIG_From_int((int)(result));
23646 }
23647 {
23648 if (temp2)
23649 delete arg2;
23650 }
23651 return resultobj;
23652 fail:
23653 {
23654 if (temp2)
23655 delete arg2;
23656 }
23657 return NULL;
23658 }
23659
23660
23661 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23662 PyObject *resultobj;
23663 wxDateTime *arg1 = (wxDateTime *) 0 ;
23664 wxString *arg2 = 0 ;
23665 int result;
23666 bool temp2 = false ;
23667 PyObject * obj0 = 0 ;
23668 PyObject * obj1 = 0 ;
23669 char *kwnames[] = {
23670 (char *) "self",(char *) "time", NULL
23671 };
23672
23673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23675 if (SWIG_arg_fail(1)) SWIG_fail;
23676 {
23677 arg2 = wxString_in_helper(obj1);
23678 if (arg2 == NULL) SWIG_fail;
23679 temp2 = true;
23680 }
23681 {
23682 PyThreadState* __tstate = wxPyBeginAllowThreads();
23683 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23684
23685 wxPyEndAllowThreads(__tstate);
23686 if (PyErr_Occurred()) SWIG_fail;
23687 }
23688 {
23689 resultobj = SWIG_From_int((int)(result));
23690 }
23691 {
23692 if (temp2)
23693 delete arg2;
23694 }
23695 return resultobj;
23696 fail:
23697 {
23698 if (temp2)
23699 delete arg2;
23700 }
23701 return NULL;
23702 }
23703
23704
23705 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23706 PyObject *resultobj;
23707 wxDateTime *arg1 = (wxDateTime *) 0 ;
23708 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23709 wxString *arg2 = (wxString *) &arg2_defvalue ;
23710 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23711 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23712 wxString result;
23713 bool temp2 = false ;
23714 bool temp3 = false ;
23715 PyObject * obj0 = 0 ;
23716 PyObject * obj1 = 0 ;
23717 PyObject * obj2 = 0 ;
23718 char *kwnames[] = {
23719 (char *) "self",(char *) "format",(char *) "tz", NULL
23720 };
23721
23722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23724 if (SWIG_arg_fail(1)) SWIG_fail;
23725 if (obj1) {
23726 {
23727 arg2 = wxString_in_helper(obj1);
23728 if (arg2 == NULL) SWIG_fail;
23729 temp2 = true;
23730 }
23731 }
23732 if (obj2) {
23733 {
23734 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23735 temp3 = true;
23736 }
23737 }
23738 {
23739 PyThreadState* __tstate = wxPyBeginAllowThreads();
23740 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23741
23742 wxPyEndAllowThreads(__tstate);
23743 if (PyErr_Occurred()) SWIG_fail;
23744 }
23745 {
23746 #if wxUSE_UNICODE
23747 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23748 #else
23749 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23750 #endif
23751 }
23752 {
23753 if (temp2)
23754 delete arg2;
23755 }
23756 {
23757 if (temp3) delete arg3;
23758 }
23759 return resultobj;
23760 fail:
23761 {
23762 if (temp2)
23763 delete arg2;
23764 }
23765 {
23766 if (temp3) delete arg3;
23767 }
23768 return NULL;
23769 }
23770
23771
23772 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23773 PyObject *resultobj;
23774 wxDateTime *arg1 = (wxDateTime *) 0 ;
23775 wxString result;
23776 PyObject * obj0 = 0 ;
23777 char *kwnames[] = {
23778 (char *) "self", NULL
23779 };
23780
23781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23783 if (SWIG_arg_fail(1)) SWIG_fail;
23784 {
23785 PyThreadState* __tstate = wxPyBeginAllowThreads();
23786 result = ((wxDateTime const *)arg1)->FormatDate();
23787
23788 wxPyEndAllowThreads(__tstate);
23789 if (PyErr_Occurred()) SWIG_fail;
23790 }
23791 {
23792 #if wxUSE_UNICODE
23793 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23794 #else
23795 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23796 #endif
23797 }
23798 return resultobj;
23799 fail:
23800 return NULL;
23801 }
23802
23803
23804 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23805 PyObject *resultobj;
23806 wxDateTime *arg1 = (wxDateTime *) 0 ;
23807 wxString result;
23808 PyObject * obj0 = 0 ;
23809 char *kwnames[] = {
23810 (char *) "self", NULL
23811 };
23812
23813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23815 if (SWIG_arg_fail(1)) SWIG_fail;
23816 {
23817 PyThreadState* __tstate = wxPyBeginAllowThreads();
23818 result = ((wxDateTime const *)arg1)->FormatTime();
23819
23820 wxPyEndAllowThreads(__tstate);
23821 if (PyErr_Occurred()) SWIG_fail;
23822 }
23823 {
23824 #if wxUSE_UNICODE
23825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23826 #else
23827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23828 #endif
23829 }
23830 return resultobj;
23831 fail:
23832 return NULL;
23833 }
23834
23835
23836 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23837 PyObject *resultobj;
23838 wxDateTime *arg1 = (wxDateTime *) 0 ;
23839 wxString result;
23840 PyObject * obj0 = 0 ;
23841 char *kwnames[] = {
23842 (char *) "self", NULL
23843 };
23844
23845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23847 if (SWIG_arg_fail(1)) SWIG_fail;
23848 {
23849 PyThreadState* __tstate = wxPyBeginAllowThreads();
23850 result = ((wxDateTime const *)arg1)->FormatISODate();
23851
23852 wxPyEndAllowThreads(__tstate);
23853 if (PyErr_Occurred()) SWIG_fail;
23854 }
23855 {
23856 #if wxUSE_UNICODE
23857 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23858 #else
23859 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23860 #endif
23861 }
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23869 PyObject *resultobj;
23870 wxDateTime *arg1 = (wxDateTime *) 0 ;
23871 wxString result;
23872 PyObject * obj0 = 0 ;
23873 char *kwnames[] = {
23874 (char *) "self", NULL
23875 };
23876
23877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23879 if (SWIG_arg_fail(1)) SWIG_fail;
23880 {
23881 PyThreadState* __tstate = wxPyBeginAllowThreads();
23882 result = ((wxDateTime const *)arg1)->FormatISOTime();
23883
23884 wxPyEndAllowThreads(__tstate);
23885 if (PyErr_Occurred()) SWIG_fail;
23886 }
23887 {
23888 #if wxUSE_UNICODE
23889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23890 #else
23891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23892 #endif
23893 }
23894 return resultobj;
23895 fail:
23896 return NULL;
23897 }
23898
23899
23900 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23901 PyObject *obj;
23902 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23903 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23904 Py_INCREF(obj);
23905 return Py_BuildValue((char *)"");
23906 }
23907 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23908 PyObject *resultobj;
23909 long arg1 ;
23910 wxTimeSpan result;
23911 PyObject * obj0 = 0 ;
23912 char *kwnames[] = {
23913 (char *) "sec", NULL
23914 };
23915
23916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23917 {
23918 arg1 = (long)(SWIG_As_long(obj0));
23919 if (SWIG_arg_fail(1)) SWIG_fail;
23920 }
23921 {
23922 PyThreadState* __tstate = wxPyBeginAllowThreads();
23923 result = wxTimeSpan::Seconds(arg1);
23924
23925 wxPyEndAllowThreads(__tstate);
23926 if (PyErr_Occurred()) SWIG_fail;
23927 }
23928 {
23929 wxTimeSpan * resultptr;
23930 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23931 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23932 }
23933 return resultobj;
23934 fail:
23935 return NULL;
23936 }
23937
23938
23939 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23940 PyObject *resultobj;
23941 wxTimeSpan result;
23942 char *kwnames[] = {
23943 NULL
23944 };
23945
23946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23947 {
23948 PyThreadState* __tstate = wxPyBeginAllowThreads();
23949 result = wxTimeSpan::Second();
23950
23951 wxPyEndAllowThreads(__tstate);
23952 if (PyErr_Occurred()) SWIG_fail;
23953 }
23954 {
23955 wxTimeSpan * resultptr;
23956 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23958 }
23959 return resultobj;
23960 fail:
23961 return NULL;
23962 }
23963
23964
23965 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23966 PyObject *resultobj;
23967 long arg1 ;
23968 wxTimeSpan result;
23969 PyObject * obj0 = 0 ;
23970 char *kwnames[] = {
23971 (char *) "min", NULL
23972 };
23973
23974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23975 {
23976 arg1 = (long)(SWIG_As_long(obj0));
23977 if (SWIG_arg_fail(1)) SWIG_fail;
23978 }
23979 {
23980 PyThreadState* __tstate = wxPyBeginAllowThreads();
23981 result = wxTimeSpan::Minutes(arg1);
23982
23983 wxPyEndAllowThreads(__tstate);
23984 if (PyErr_Occurred()) SWIG_fail;
23985 }
23986 {
23987 wxTimeSpan * resultptr;
23988 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23989 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23990 }
23991 return resultobj;
23992 fail:
23993 return NULL;
23994 }
23995
23996
23997 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23998 PyObject *resultobj;
23999 wxTimeSpan result;
24000 char *kwnames[] = {
24001 NULL
24002 };
24003
24004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
24005 {
24006 PyThreadState* __tstate = wxPyBeginAllowThreads();
24007 result = wxTimeSpan::Minute();
24008
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 {
24013 wxTimeSpan * resultptr;
24014 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24015 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24016 }
24017 return resultobj;
24018 fail:
24019 return NULL;
24020 }
24021
24022
24023 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
24024 PyObject *resultobj;
24025 long arg1 ;
24026 wxTimeSpan result;
24027 PyObject * obj0 = 0 ;
24028 char *kwnames[] = {
24029 (char *) "hours", NULL
24030 };
24031
24032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
24033 {
24034 arg1 = (long)(SWIG_As_long(obj0));
24035 if (SWIG_arg_fail(1)) SWIG_fail;
24036 }
24037 {
24038 PyThreadState* __tstate = wxPyBeginAllowThreads();
24039 result = wxTimeSpan::Hours(arg1);
24040
24041 wxPyEndAllowThreads(__tstate);
24042 if (PyErr_Occurred()) SWIG_fail;
24043 }
24044 {
24045 wxTimeSpan * resultptr;
24046 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24047 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24048 }
24049 return resultobj;
24050 fail:
24051 return NULL;
24052 }
24053
24054
24055 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24056 PyObject *resultobj;
24057 wxTimeSpan result;
24058 char *kwnames[] = {
24059 NULL
24060 };
24061
24062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24063 {
24064 PyThreadState* __tstate = wxPyBeginAllowThreads();
24065 result = wxTimeSpan::Hour();
24066
24067 wxPyEndAllowThreads(__tstate);
24068 if (PyErr_Occurred()) SWIG_fail;
24069 }
24070 {
24071 wxTimeSpan * resultptr;
24072 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24073 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24074 }
24075 return resultobj;
24076 fail:
24077 return NULL;
24078 }
24079
24080
24081 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24082 PyObject *resultobj;
24083 long arg1 ;
24084 wxTimeSpan result;
24085 PyObject * obj0 = 0 ;
24086 char *kwnames[] = {
24087 (char *) "days", NULL
24088 };
24089
24090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24091 {
24092 arg1 = (long)(SWIG_As_long(obj0));
24093 if (SWIG_arg_fail(1)) SWIG_fail;
24094 }
24095 {
24096 PyThreadState* __tstate = wxPyBeginAllowThreads();
24097 result = wxTimeSpan::Days(arg1);
24098
24099 wxPyEndAllowThreads(__tstate);
24100 if (PyErr_Occurred()) SWIG_fail;
24101 }
24102 {
24103 wxTimeSpan * resultptr;
24104 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24105 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24106 }
24107 return resultobj;
24108 fail:
24109 return NULL;
24110 }
24111
24112
24113 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24114 PyObject *resultobj;
24115 wxTimeSpan result;
24116 char *kwnames[] = {
24117 NULL
24118 };
24119
24120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24121 {
24122 PyThreadState* __tstate = wxPyBeginAllowThreads();
24123 result = wxTimeSpan::Day();
24124
24125 wxPyEndAllowThreads(__tstate);
24126 if (PyErr_Occurred()) SWIG_fail;
24127 }
24128 {
24129 wxTimeSpan * resultptr;
24130 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24131 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24132 }
24133 return resultobj;
24134 fail:
24135 return NULL;
24136 }
24137
24138
24139 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24140 PyObject *resultobj;
24141 long arg1 ;
24142 wxTimeSpan result;
24143 PyObject * obj0 = 0 ;
24144 char *kwnames[] = {
24145 (char *) "days", NULL
24146 };
24147
24148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24149 {
24150 arg1 = (long)(SWIG_As_long(obj0));
24151 if (SWIG_arg_fail(1)) SWIG_fail;
24152 }
24153 {
24154 PyThreadState* __tstate = wxPyBeginAllowThreads();
24155 result = wxTimeSpan::Weeks(arg1);
24156
24157 wxPyEndAllowThreads(__tstate);
24158 if (PyErr_Occurred()) SWIG_fail;
24159 }
24160 {
24161 wxTimeSpan * resultptr;
24162 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24163 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24164 }
24165 return resultobj;
24166 fail:
24167 return NULL;
24168 }
24169
24170
24171 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24172 PyObject *resultobj;
24173 wxTimeSpan result;
24174 char *kwnames[] = {
24175 NULL
24176 };
24177
24178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24179 {
24180 PyThreadState* __tstate = wxPyBeginAllowThreads();
24181 result = wxTimeSpan::Week();
24182
24183 wxPyEndAllowThreads(__tstate);
24184 if (PyErr_Occurred()) SWIG_fail;
24185 }
24186 {
24187 wxTimeSpan * resultptr;
24188 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24189 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24190 }
24191 return resultobj;
24192 fail:
24193 return NULL;
24194 }
24195
24196
24197 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24198 PyObject *resultobj;
24199 long arg1 = (long) 0 ;
24200 long arg2 = (long) 0 ;
24201 long arg3 = (long) 0 ;
24202 long arg4 = (long) 0 ;
24203 wxTimeSpan *result;
24204 PyObject * obj0 = 0 ;
24205 PyObject * obj1 = 0 ;
24206 PyObject * obj2 = 0 ;
24207 PyObject * obj3 = 0 ;
24208 char *kwnames[] = {
24209 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24210 };
24211
24212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24213 if (obj0) {
24214 {
24215 arg1 = (long)(SWIG_As_long(obj0));
24216 if (SWIG_arg_fail(1)) SWIG_fail;
24217 }
24218 }
24219 if (obj1) {
24220 {
24221 arg2 = (long)(SWIG_As_long(obj1));
24222 if (SWIG_arg_fail(2)) SWIG_fail;
24223 }
24224 }
24225 if (obj2) {
24226 {
24227 arg3 = (long)(SWIG_As_long(obj2));
24228 if (SWIG_arg_fail(3)) SWIG_fail;
24229 }
24230 }
24231 if (obj3) {
24232 {
24233 arg4 = (long)(SWIG_As_long(obj3));
24234 if (SWIG_arg_fail(4)) SWIG_fail;
24235 }
24236 }
24237 {
24238 PyThreadState* __tstate = wxPyBeginAllowThreads();
24239 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24240
24241 wxPyEndAllowThreads(__tstate);
24242 if (PyErr_Occurred()) SWIG_fail;
24243 }
24244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24245 return resultobj;
24246 fail:
24247 return NULL;
24248 }
24249
24250
24251 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24252 PyObject *resultobj;
24253 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24254 PyObject * obj0 = 0 ;
24255 char *kwnames[] = {
24256 (char *) "self", NULL
24257 };
24258
24259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24261 if (SWIG_arg_fail(1)) SWIG_fail;
24262 {
24263 PyThreadState* __tstate = wxPyBeginAllowThreads();
24264 delete arg1;
24265
24266 wxPyEndAllowThreads(__tstate);
24267 if (PyErr_Occurred()) SWIG_fail;
24268 }
24269 Py_INCREF(Py_None); resultobj = Py_None;
24270 return resultobj;
24271 fail:
24272 return NULL;
24273 }
24274
24275
24276 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24277 PyObject *resultobj;
24278 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24279 wxTimeSpan *arg2 = 0 ;
24280 wxTimeSpan *result;
24281 PyObject * obj0 = 0 ;
24282 PyObject * obj1 = 0 ;
24283 char *kwnames[] = {
24284 (char *) "self",(char *) "diff", NULL
24285 };
24286
24287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24289 if (SWIG_arg_fail(1)) SWIG_fail;
24290 {
24291 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24292 if (SWIG_arg_fail(2)) SWIG_fail;
24293 if (arg2 == NULL) {
24294 SWIG_null_ref("wxTimeSpan");
24295 }
24296 if (SWIG_arg_fail(2)) SWIG_fail;
24297 }
24298 {
24299 PyThreadState* __tstate = wxPyBeginAllowThreads();
24300 {
24301 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24302 result = (wxTimeSpan *) &_result_ref;
24303 }
24304
24305 wxPyEndAllowThreads(__tstate);
24306 if (PyErr_Occurred()) SWIG_fail;
24307 }
24308 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24309 return resultobj;
24310 fail:
24311 return NULL;
24312 }
24313
24314
24315 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24316 PyObject *resultobj;
24317 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24318 wxTimeSpan *arg2 = 0 ;
24319 wxTimeSpan *result;
24320 PyObject * obj0 = 0 ;
24321 PyObject * obj1 = 0 ;
24322 char *kwnames[] = {
24323 (char *) "self",(char *) "diff", NULL
24324 };
24325
24326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24328 if (SWIG_arg_fail(1)) SWIG_fail;
24329 {
24330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24331 if (SWIG_arg_fail(2)) SWIG_fail;
24332 if (arg2 == NULL) {
24333 SWIG_null_ref("wxTimeSpan");
24334 }
24335 if (SWIG_arg_fail(2)) SWIG_fail;
24336 }
24337 {
24338 PyThreadState* __tstate = wxPyBeginAllowThreads();
24339 {
24340 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24341 result = (wxTimeSpan *) &_result_ref;
24342 }
24343
24344 wxPyEndAllowThreads(__tstate);
24345 if (PyErr_Occurred()) SWIG_fail;
24346 }
24347 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24348 return resultobj;
24349 fail:
24350 return NULL;
24351 }
24352
24353
24354 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24355 PyObject *resultobj;
24356 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24357 int arg2 ;
24358 wxTimeSpan *result;
24359 PyObject * obj0 = 0 ;
24360 PyObject * obj1 = 0 ;
24361 char *kwnames[] = {
24362 (char *) "self",(char *) "n", NULL
24363 };
24364
24365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24367 if (SWIG_arg_fail(1)) SWIG_fail;
24368 {
24369 arg2 = (int)(SWIG_As_int(obj1));
24370 if (SWIG_arg_fail(2)) SWIG_fail;
24371 }
24372 {
24373 PyThreadState* __tstate = wxPyBeginAllowThreads();
24374 {
24375 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24376 result = (wxTimeSpan *) &_result_ref;
24377 }
24378
24379 wxPyEndAllowThreads(__tstate);
24380 if (PyErr_Occurred()) SWIG_fail;
24381 }
24382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24383 return resultobj;
24384 fail:
24385 return NULL;
24386 }
24387
24388
24389 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24390 PyObject *resultobj;
24391 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24392 wxTimeSpan *result;
24393 PyObject * obj0 = 0 ;
24394 char *kwnames[] = {
24395 (char *) "self", NULL
24396 };
24397
24398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24400 if (SWIG_arg_fail(1)) SWIG_fail;
24401 {
24402 PyThreadState* __tstate = wxPyBeginAllowThreads();
24403 {
24404 wxTimeSpan &_result_ref = (arg1)->Neg();
24405 result = (wxTimeSpan *) &_result_ref;
24406 }
24407
24408 wxPyEndAllowThreads(__tstate);
24409 if (PyErr_Occurred()) SWIG_fail;
24410 }
24411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24412 return resultobj;
24413 fail:
24414 return NULL;
24415 }
24416
24417
24418 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24419 PyObject *resultobj;
24420 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24421 wxTimeSpan result;
24422 PyObject * obj0 = 0 ;
24423 char *kwnames[] = {
24424 (char *) "self", NULL
24425 };
24426
24427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24429 if (SWIG_arg_fail(1)) SWIG_fail;
24430 {
24431 PyThreadState* __tstate = wxPyBeginAllowThreads();
24432 result = ((wxTimeSpan const *)arg1)->Abs();
24433
24434 wxPyEndAllowThreads(__tstate);
24435 if (PyErr_Occurred()) SWIG_fail;
24436 }
24437 {
24438 wxTimeSpan * resultptr;
24439 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24440 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24441 }
24442 return resultobj;
24443 fail:
24444 return NULL;
24445 }
24446
24447
24448 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24449 PyObject *resultobj;
24450 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24451 wxTimeSpan *arg2 = 0 ;
24452 wxTimeSpan *result;
24453 PyObject * obj0 = 0 ;
24454 PyObject * obj1 = 0 ;
24455 char *kwnames[] = {
24456 (char *) "self",(char *) "diff", NULL
24457 };
24458
24459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24461 if (SWIG_arg_fail(1)) SWIG_fail;
24462 {
24463 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24464 if (SWIG_arg_fail(2)) SWIG_fail;
24465 if (arg2 == NULL) {
24466 SWIG_null_ref("wxTimeSpan");
24467 }
24468 if (SWIG_arg_fail(2)) SWIG_fail;
24469 }
24470 {
24471 PyThreadState* __tstate = wxPyBeginAllowThreads();
24472 {
24473 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24474 result = (wxTimeSpan *) &_result_ref;
24475 }
24476
24477 wxPyEndAllowThreads(__tstate);
24478 if (PyErr_Occurred()) SWIG_fail;
24479 }
24480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24481 return resultobj;
24482 fail:
24483 return NULL;
24484 }
24485
24486
24487 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24488 PyObject *resultobj;
24489 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24490 wxTimeSpan *arg2 = 0 ;
24491 wxTimeSpan *result;
24492 PyObject * obj0 = 0 ;
24493 PyObject * obj1 = 0 ;
24494 char *kwnames[] = {
24495 (char *) "self",(char *) "diff", NULL
24496 };
24497
24498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24500 if (SWIG_arg_fail(1)) SWIG_fail;
24501 {
24502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24503 if (SWIG_arg_fail(2)) SWIG_fail;
24504 if (arg2 == NULL) {
24505 SWIG_null_ref("wxTimeSpan");
24506 }
24507 if (SWIG_arg_fail(2)) SWIG_fail;
24508 }
24509 {
24510 PyThreadState* __tstate = wxPyBeginAllowThreads();
24511 {
24512 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24513 result = (wxTimeSpan *) &_result_ref;
24514 }
24515
24516 wxPyEndAllowThreads(__tstate);
24517 if (PyErr_Occurred()) SWIG_fail;
24518 }
24519 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24520 return resultobj;
24521 fail:
24522 return NULL;
24523 }
24524
24525
24526 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24527 PyObject *resultobj;
24528 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24529 int arg2 ;
24530 wxTimeSpan *result;
24531 PyObject * obj0 = 0 ;
24532 PyObject * obj1 = 0 ;
24533 char *kwnames[] = {
24534 (char *) "self",(char *) "n", NULL
24535 };
24536
24537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24539 if (SWIG_arg_fail(1)) SWIG_fail;
24540 {
24541 arg2 = (int)(SWIG_As_int(obj1));
24542 if (SWIG_arg_fail(2)) SWIG_fail;
24543 }
24544 {
24545 PyThreadState* __tstate = wxPyBeginAllowThreads();
24546 {
24547 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24548 result = (wxTimeSpan *) &_result_ref;
24549 }
24550
24551 wxPyEndAllowThreads(__tstate);
24552 if (PyErr_Occurred()) SWIG_fail;
24553 }
24554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24555 return resultobj;
24556 fail:
24557 return NULL;
24558 }
24559
24560
24561 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24562 PyObject *resultobj;
24563 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24564 wxTimeSpan *result;
24565 PyObject * obj0 = 0 ;
24566 char *kwnames[] = {
24567 (char *) "self", NULL
24568 };
24569
24570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24572 if (SWIG_arg_fail(1)) SWIG_fail;
24573 {
24574 PyThreadState* __tstate = wxPyBeginAllowThreads();
24575 {
24576 wxTimeSpan &_result_ref = (arg1)->operator -();
24577 result = (wxTimeSpan *) &_result_ref;
24578 }
24579
24580 wxPyEndAllowThreads(__tstate);
24581 if (PyErr_Occurred()) SWIG_fail;
24582 }
24583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24584 return resultobj;
24585 fail:
24586 return NULL;
24587 }
24588
24589
24590 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24591 PyObject *resultobj;
24592 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24593 wxTimeSpan *arg2 = 0 ;
24594 wxTimeSpan result;
24595 PyObject * obj0 = 0 ;
24596 PyObject * obj1 = 0 ;
24597 char *kwnames[] = {
24598 (char *) "self",(char *) "other", NULL
24599 };
24600
24601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24603 if (SWIG_arg_fail(1)) SWIG_fail;
24604 {
24605 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24606 if (SWIG_arg_fail(2)) SWIG_fail;
24607 if (arg2 == NULL) {
24608 SWIG_null_ref("wxTimeSpan");
24609 }
24610 if (SWIG_arg_fail(2)) SWIG_fail;
24611 }
24612 {
24613 PyThreadState* __tstate = wxPyBeginAllowThreads();
24614 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24615
24616 wxPyEndAllowThreads(__tstate);
24617 if (PyErr_Occurred()) SWIG_fail;
24618 }
24619 {
24620 wxTimeSpan * resultptr;
24621 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24622 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24623 }
24624 return resultobj;
24625 fail:
24626 return NULL;
24627 }
24628
24629
24630 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24631 PyObject *resultobj;
24632 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24633 wxTimeSpan *arg2 = 0 ;
24634 wxTimeSpan result;
24635 PyObject * obj0 = 0 ;
24636 PyObject * obj1 = 0 ;
24637 char *kwnames[] = {
24638 (char *) "self",(char *) "other", NULL
24639 };
24640
24641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24643 if (SWIG_arg_fail(1)) SWIG_fail;
24644 {
24645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24646 if (SWIG_arg_fail(2)) SWIG_fail;
24647 if (arg2 == NULL) {
24648 SWIG_null_ref("wxTimeSpan");
24649 }
24650 if (SWIG_arg_fail(2)) SWIG_fail;
24651 }
24652 {
24653 PyThreadState* __tstate = wxPyBeginAllowThreads();
24654 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24655
24656 wxPyEndAllowThreads(__tstate);
24657 if (PyErr_Occurred()) SWIG_fail;
24658 }
24659 {
24660 wxTimeSpan * resultptr;
24661 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24662 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24663 }
24664 return resultobj;
24665 fail:
24666 return NULL;
24667 }
24668
24669
24670 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24671 PyObject *resultobj;
24672 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24673 int arg2 ;
24674 wxTimeSpan result;
24675 PyObject * obj0 = 0 ;
24676 PyObject * obj1 = 0 ;
24677 char *kwnames[] = {
24678 (char *) "self",(char *) "n", NULL
24679 };
24680
24681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24683 if (SWIG_arg_fail(1)) SWIG_fail;
24684 {
24685 arg2 = (int)(SWIG_As_int(obj1));
24686 if (SWIG_arg_fail(2)) SWIG_fail;
24687 }
24688 {
24689 PyThreadState* __tstate = wxPyBeginAllowThreads();
24690 result = wxTimeSpan___mul__(arg1,arg2);
24691
24692 wxPyEndAllowThreads(__tstate);
24693 if (PyErr_Occurred()) SWIG_fail;
24694 }
24695 {
24696 wxTimeSpan * resultptr;
24697 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24698 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24699 }
24700 return resultobj;
24701 fail:
24702 return NULL;
24703 }
24704
24705
24706 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24707 PyObject *resultobj;
24708 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24709 int arg2 ;
24710 wxTimeSpan result;
24711 PyObject * obj0 = 0 ;
24712 PyObject * obj1 = 0 ;
24713 char *kwnames[] = {
24714 (char *) "self",(char *) "n", NULL
24715 };
24716
24717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24719 if (SWIG_arg_fail(1)) SWIG_fail;
24720 {
24721 arg2 = (int)(SWIG_As_int(obj1));
24722 if (SWIG_arg_fail(2)) SWIG_fail;
24723 }
24724 {
24725 PyThreadState* __tstate = wxPyBeginAllowThreads();
24726 result = wxTimeSpan___rmul__(arg1,arg2);
24727
24728 wxPyEndAllowThreads(__tstate);
24729 if (PyErr_Occurred()) SWIG_fail;
24730 }
24731 {
24732 wxTimeSpan * resultptr;
24733 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24734 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24735 }
24736 return resultobj;
24737 fail:
24738 return NULL;
24739 }
24740
24741
24742 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24743 PyObject *resultobj;
24744 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24745 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24746 bool result;
24747 PyObject * obj0 = 0 ;
24748 PyObject * obj1 = 0 ;
24749 char *kwnames[] = {
24750 (char *) "self",(char *) "other", NULL
24751 };
24752
24753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24755 if (SWIG_arg_fail(1)) SWIG_fail;
24756 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24757 if (SWIG_arg_fail(2)) SWIG_fail;
24758 {
24759 PyThreadState* __tstate = wxPyBeginAllowThreads();
24760 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24761
24762 wxPyEndAllowThreads(__tstate);
24763 if (PyErr_Occurred()) SWIG_fail;
24764 }
24765 {
24766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24767 }
24768 return resultobj;
24769 fail:
24770 return NULL;
24771 }
24772
24773
24774 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24775 PyObject *resultobj;
24776 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24777 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24778 bool result;
24779 PyObject * obj0 = 0 ;
24780 PyObject * obj1 = 0 ;
24781 char *kwnames[] = {
24782 (char *) "self",(char *) "other", NULL
24783 };
24784
24785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24787 if (SWIG_arg_fail(1)) SWIG_fail;
24788 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24789 if (SWIG_arg_fail(2)) SWIG_fail;
24790 {
24791 PyThreadState* __tstate = wxPyBeginAllowThreads();
24792 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24793
24794 wxPyEndAllowThreads(__tstate);
24795 if (PyErr_Occurred()) SWIG_fail;
24796 }
24797 {
24798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24799 }
24800 return resultobj;
24801 fail:
24802 return NULL;
24803 }
24804
24805
24806 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24807 PyObject *resultobj;
24808 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24809 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24810 bool result;
24811 PyObject * obj0 = 0 ;
24812 PyObject * obj1 = 0 ;
24813 char *kwnames[] = {
24814 (char *) "self",(char *) "other", NULL
24815 };
24816
24817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24819 if (SWIG_arg_fail(1)) SWIG_fail;
24820 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24821 if (SWIG_arg_fail(2)) SWIG_fail;
24822 {
24823 PyThreadState* __tstate = wxPyBeginAllowThreads();
24824 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24825
24826 wxPyEndAllowThreads(__tstate);
24827 if (PyErr_Occurred()) SWIG_fail;
24828 }
24829 {
24830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24831 }
24832 return resultobj;
24833 fail:
24834 return NULL;
24835 }
24836
24837
24838 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24839 PyObject *resultobj;
24840 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24841 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24842 bool result;
24843 PyObject * obj0 = 0 ;
24844 PyObject * obj1 = 0 ;
24845 char *kwnames[] = {
24846 (char *) "self",(char *) "other", NULL
24847 };
24848
24849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24851 if (SWIG_arg_fail(1)) SWIG_fail;
24852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24853 if (SWIG_arg_fail(2)) SWIG_fail;
24854 {
24855 PyThreadState* __tstate = wxPyBeginAllowThreads();
24856 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24857
24858 wxPyEndAllowThreads(__tstate);
24859 if (PyErr_Occurred()) SWIG_fail;
24860 }
24861 {
24862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24863 }
24864 return resultobj;
24865 fail:
24866 return NULL;
24867 }
24868
24869
24870 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24871 PyObject *resultobj;
24872 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24873 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24874 bool result;
24875 PyObject * obj0 = 0 ;
24876 PyObject * obj1 = 0 ;
24877 char *kwnames[] = {
24878 (char *) "self",(char *) "other", NULL
24879 };
24880
24881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24883 if (SWIG_arg_fail(1)) SWIG_fail;
24884 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24885 if (SWIG_arg_fail(2)) SWIG_fail;
24886 {
24887 PyThreadState* __tstate = wxPyBeginAllowThreads();
24888 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24889
24890 wxPyEndAllowThreads(__tstate);
24891 if (PyErr_Occurred()) SWIG_fail;
24892 }
24893 {
24894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24895 }
24896 return resultobj;
24897 fail:
24898 return NULL;
24899 }
24900
24901
24902 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24903 PyObject *resultobj;
24904 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24905 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24906 bool result;
24907 PyObject * obj0 = 0 ;
24908 PyObject * obj1 = 0 ;
24909 char *kwnames[] = {
24910 (char *) "self",(char *) "other", NULL
24911 };
24912
24913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24915 if (SWIG_arg_fail(1)) SWIG_fail;
24916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24917 if (SWIG_arg_fail(2)) SWIG_fail;
24918 {
24919 PyThreadState* __tstate = wxPyBeginAllowThreads();
24920 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24921
24922 wxPyEndAllowThreads(__tstate);
24923 if (PyErr_Occurred()) SWIG_fail;
24924 }
24925 {
24926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24927 }
24928 return resultobj;
24929 fail:
24930 return NULL;
24931 }
24932
24933
24934 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24935 PyObject *resultobj;
24936 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24937 bool result;
24938 PyObject * obj0 = 0 ;
24939 char *kwnames[] = {
24940 (char *) "self", NULL
24941 };
24942
24943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24945 if (SWIG_arg_fail(1)) SWIG_fail;
24946 {
24947 PyThreadState* __tstate = wxPyBeginAllowThreads();
24948 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24949
24950 wxPyEndAllowThreads(__tstate);
24951 if (PyErr_Occurred()) SWIG_fail;
24952 }
24953 {
24954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24955 }
24956 return resultobj;
24957 fail:
24958 return NULL;
24959 }
24960
24961
24962 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24963 PyObject *resultobj;
24964 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24965 bool result;
24966 PyObject * obj0 = 0 ;
24967 char *kwnames[] = {
24968 (char *) "self", NULL
24969 };
24970
24971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24973 if (SWIG_arg_fail(1)) SWIG_fail;
24974 {
24975 PyThreadState* __tstate = wxPyBeginAllowThreads();
24976 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24977
24978 wxPyEndAllowThreads(__tstate);
24979 if (PyErr_Occurred()) SWIG_fail;
24980 }
24981 {
24982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24983 }
24984 return resultobj;
24985 fail:
24986 return NULL;
24987 }
24988
24989
24990 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24991 PyObject *resultobj;
24992 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24993 bool result;
24994 PyObject * obj0 = 0 ;
24995 char *kwnames[] = {
24996 (char *) "self", NULL
24997 };
24998
24999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
25000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25001 if (SWIG_arg_fail(1)) SWIG_fail;
25002 {
25003 PyThreadState* __tstate = wxPyBeginAllowThreads();
25004 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
25005
25006 wxPyEndAllowThreads(__tstate);
25007 if (PyErr_Occurred()) SWIG_fail;
25008 }
25009 {
25010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25011 }
25012 return resultobj;
25013 fail:
25014 return NULL;
25015 }
25016
25017
25018 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
25019 PyObject *resultobj;
25020 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25021 wxTimeSpan *arg2 = 0 ;
25022 bool result;
25023 PyObject * obj0 = 0 ;
25024 PyObject * obj1 = 0 ;
25025 char *kwnames[] = {
25026 (char *) "self",(char *) "ts", NULL
25027 };
25028
25029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
25030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25031 if (SWIG_arg_fail(1)) SWIG_fail;
25032 {
25033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25034 if (SWIG_arg_fail(2)) SWIG_fail;
25035 if (arg2 == NULL) {
25036 SWIG_null_ref("wxTimeSpan");
25037 }
25038 if (SWIG_arg_fail(2)) SWIG_fail;
25039 }
25040 {
25041 PyThreadState* __tstate = wxPyBeginAllowThreads();
25042 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
25043
25044 wxPyEndAllowThreads(__tstate);
25045 if (PyErr_Occurred()) SWIG_fail;
25046 }
25047 {
25048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25049 }
25050 return resultobj;
25051 fail:
25052 return NULL;
25053 }
25054
25055
25056 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25057 PyObject *resultobj;
25058 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25059 wxTimeSpan *arg2 = 0 ;
25060 bool result;
25061 PyObject * obj0 = 0 ;
25062 PyObject * obj1 = 0 ;
25063 char *kwnames[] = {
25064 (char *) "self",(char *) "ts", NULL
25065 };
25066
25067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25069 if (SWIG_arg_fail(1)) SWIG_fail;
25070 {
25071 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25072 if (SWIG_arg_fail(2)) SWIG_fail;
25073 if (arg2 == NULL) {
25074 SWIG_null_ref("wxTimeSpan");
25075 }
25076 if (SWIG_arg_fail(2)) SWIG_fail;
25077 }
25078 {
25079 PyThreadState* __tstate = wxPyBeginAllowThreads();
25080 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25081
25082 wxPyEndAllowThreads(__tstate);
25083 if (PyErr_Occurred()) SWIG_fail;
25084 }
25085 {
25086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25087 }
25088 return resultobj;
25089 fail:
25090 return NULL;
25091 }
25092
25093
25094 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25095 PyObject *resultobj;
25096 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25097 wxTimeSpan *arg2 = 0 ;
25098 bool result;
25099 PyObject * obj0 = 0 ;
25100 PyObject * obj1 = 0 ;
25101 char *kwnames[] = {
25102 (char *) "self",(char *) "t", NULL
25103 };
25104
25105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25107 if (SWIG_arg_fail(1)) SWIG_fail;
25108 {
25109 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25110 if (SWIG_arg_fail(2)) SWIG_fail;
25111 if (arg2 == NULL) {
25112 SWIG_null_ref("wxTimeSpan");
25113 }
25114 if (SWIG_arg_fail(2)) SWIG_fail;
25115 }
25116 {
25117 PyThreadState* __tstate = wxPyBeginAllowThreads();
25118 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25119
25120 wxPyEndAllowThreads(__tstate);
25121 if (PyErr_Occurred()) SWIG_fail;
25122 }
25123 {
25124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25125 }
25126 return resultobj;
25127 fail:
25128 return NULL;
25129 }
25130
25131
25132 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25133 PyObject *resultobj;
25134 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25135 int result;
25136 PyObject * obj0 = 0 ;
25137 char *kwnames[] = {
25138 (char *) "self", NULL
25139 };
25140
25141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25143 if (SWIG_arg_fail(1)) SWIG_fail;
25144 {
25145 PyThreadState* __tstate = wxPyBeginAllowThreads();
25146 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25147
25148 wxPyEndAllowThreads(__tstate);
25149 if (PyErr_Occurred()) SWIG_fail;
25150 }
25151 {
25152 resultobj = SWIG_From_int((int)(result));
25153 }
25154 return resultobj;
25155 fail:
25156 return NULL;
25157 }
25158
25159
25160 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25161 PyObject *resultobj;
25162 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25163 int result;
25164 PyObject * obj0 = 0 ;
25165 char *kwnames[] = {
25166 (char *) "self", NULL
25167 };
25168
25169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25171 if (SWIG_arg_fail(1)) SWIG_fail;
25172 {
25173 PyThreadState* __tstate = wxPyBeginAllowThreads();
25174 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25175
25176 wxPyEndAllowThreads(__tstate);
25177 if (PyErr_Occurred()) SWIG_fail;
25178 }
25179 {
25180 resultobj = SWIG_From_int((int)(result));
25181 }
25182 return resultobj;
25183 fail:
25184 return NULL;
25185 }
25186
25187
25188 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25189 PyObject *resultobj;
25190 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25191 int result;
25192 PyObject * obj0 = 0 ;
25193 char *kwnames[] = {
25194 (char *) "self", NULL
25195 };
25196
25197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25199 if (SWIG_arg_fail(1)) SWIG_fail;
25200 {
25201 PyThreadState* __tstate = wxPyBeginAllowThreads();
25202 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25203
25204 wxPyEndAllowThreads(__tstate);
25205 if (PyErr_Occurred()) SWIG_fail;
25206 }
25207 {
25208 resultobj = SWIG_From_int((int)(result));
25209 }
25210 return resultobj;
25211 fail:
25212 return NULL;
25213 }
25214
25215
25216 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25217 PyObject *resultobj;
25218 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25219 int result;
25220 PyObject * obj0 = 0 ;
25221 char *kwnames[] = {
25222 (char *) "self", NULL
25223 };
25224
25225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25227 if (SWIG_arg_fail(1)) SWIG_fail;
25228 {
25229 PyThreadState* __tstate = wxPyBeginAllowThreads();
25230 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25231
25232 wxPyEndAllowThreads(__tstate);
25233 if (PyErr_Occurred()) SWIG_fail;
25234 }
25235 {
25236 resultobj = SWIG_From_int((int)(result));
25237 }
25238 return resultobj;
25239 fail:
25240 return NULL;
25241 }
25242
25243
25244 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25245 PyObject *resultobj;
25246 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25247 wxLongLong result;
25248 PyObject * obj0 = 0 ;
25249 char *kwnames[] = {
25250 (char *) "self", NULL
25251 };
25252
25253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25255 if (SWIG_arg_fail(1)) SWIG_fail;
25256 {
25257 PyThreadState* __tstate = wxPyBeginAllowThreads();
25258 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25259
25260 wxPyEndAllowThreads(__tstate);
25261 if (PyErr_Occurred()) SWIG_fail;
25262 }
25263 {
25264 PyObject *hi, *lo, *shifter, *shifted;
25265 hi = PyLong_FromLong( (&result)->GetHi() );
25266 lo = PyLong_FromLong( (&result)->GetLo() );
25267 shifter = PyLong_FromLong(32);
25268 shifted = PyNumber_Lshift(hi, shifter);
25269 resultobj = PyNumber_Or(shifted, lo);
25270 Py_DECREF(hi);
25271 Py_DECREF(lo);
25272 Py_DECREF(shifter);
25273 Py_DECREF(shifted);
25274 }
25275 return resultobj;
25276 fail:
25277 return NULL;
25278 }
25279
25280
25281 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25282 PyObject *resultobj;
25283 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25284 wxLongLong result;
25285 PyObject * obj0 = 0 ;
25286 char *kwnames[] = {
25287 (char *) "self", NULL
25288 };
25289
25290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25292 if (SWIG_arg_fail(1)) SWIG_fail;
25293 {
25294 PyThreadState* __tstate = wxPyBeginAllowThreads();
25295 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25296
25297 wxPyEndAllowThreads(__tstate);
25298 if (PyErr_Occurred()) SWIG_fail;
25299 }
25300 {
25301 PyObject *hi, *lo, *shifter, *shifted;
25302 hi = PyLong_FromLong( (&result)->GetHi() );
25303 lo = PyLong_FromLong( (&result)->GetLo() );
25304 shifter = PyLong_FromLong(32);
25305 shifted = PyNumber_Lshift(hi, shifter);
25306 resultobj = PyNumber_Or(shifted, lo);
25307 Py_DECREF(hi);
25308 Py_DECREF(lo);
25309 Py_DECREF(shifter);
25310 Py_DECREF(shifted);
25311 }
25312 return resultobj;
25313 fail:
25314 return NULL;
25315 }
25316
25317
25318 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25319 PyObject *resultobj;
25320 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25321 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25322 wxString *arg2 = (wxString *) &arg2_defvalue ;
25323 wxString result;
25324 bool temp2 = false ;
25325 PyObject * obj0 = 0 ;
25326 PyObject * obj1 = 0 ;
25327 char *kwnames[] = {
25328 (char *) "self",(char *) "format", NULL
25329 };
25330
25331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25333 if (SWIG_arg_fail(1)) SWIG_fail;
25334 if (obj1) {
25335 {
25336 arg2 = wxString_in_helper(obj1);
25337 if (arg2 == NULL) SWIG_fail;
25338 temp2 = true;
25339 }
25340 }
25341 {
25342 PyThreadState* __tstate = wxPyBeginAllowThreads();
25343 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25344
25345 wxPyEndAllowThreads(__tstate);
25346 if (PyErr_Occurred()) SWIG_fail;
25347 }
25348 {
25349 #if wxUSE_UNICODE
25350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25351 #else
25352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25353 #endif
25354 }
25355 {
25356 if (temp2)
25357 delete arg2;
25358 }
25359 return resultobj;
25360 fail:
25361 {
25362 if (temp2)
25363 delete arg2;
25364 }
25365 return NULL;
25366 }
25367
25368
25369 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25370 PyObject *obj;
25371 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25372 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25373 Py_INCREF(obj);
25374 return Py_BuildValue((char *)"");
25375 }
25376 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25377 PyObject *resultobj;
25378 int arg1 = (int) 0 ;
25379 int arg2 = (int) 0 ;
25380 int arg3 = (int) 0 ;
25381 int arg4 = (int) 0 ;
25382 wxDateSpan *result;
25383 PyObject * obj0 = 0 ;
25384 PyObject * obj1 = 0 ;
25385 PyObject * obj2 = 0 ;
25386 PyObject * obj3 = 0 ;
25387 char *kwnames[] = {
25388 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25389 };
25390
25391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25392 if (obj0) {
25393 {
25394 arg1 = (int)(SWIG_As_int(obj0));
25395 if (SWIG_arg_fail(1)) SWIG_fail;
25396 }
25397 }
25398 if (obj1) {
25399 {
25400 arg2 = (int)(SWIG_As_int(obj1));
25401 if (SWIG_arg_fail(2)) SWIG_fail;
25402 }
25403 }
25404 if (obj2) {
25405 {
25406 arg3 = (int)(SWIG_As_int(obj2));
25407 if (SWIG_arg_fail(3)) SWIG_fail;
25408 }
25409 }
25410 if (obj3) {
25411 {
25412 arg4 = (int)(SWIG_As_int(obj3));
25413 if (SWIG_arg_fail(4)) SWIG_fail;
25414 }
25415 }
25416 {
25417 PyThreadState* __tstate = wxPyBeginAllowThreads();
25418 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25419
25420 wxPyEndAllowThreads(__tstate);
25421 if (PyErr_Occurred()) SWIG_fail;
25422 }
25423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25424 return resultobj;
25425 fail:
25426 return NULL;
25427 }
25428
25429
25430 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25431 PyObject *resultobj;
25432 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25433 PyObject * obj0 = 0 ;
25434 char *kwnames[] = {
25435 (char *) "self", NULL
25436 };
25437
25438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25440 if (SWIG_arg_fail(1)) SWIG_fail;
25441 {
25442 PyThreadState* __tstate = wxPyBeginAllowThreads();
25443 delete arg1;
25444
25445 wxPyEndAllowThreads(__tstate);
25446 if (PyErr_Occurred()) SWIG_fail;
25447 }
25448 Py_INCREF(Py_None); resultobj = Py_None;
25449 return resultobj;
25450 fail:
25451 return NULL;
25452 }
25453
25454
25455 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25456 PyObject *resultobj;
25457 int arg1 ;
25458 wxDateSpan result;
25459 PyObject * obj0 = 0 ;
25460 char *kwnames[] = {
25461 (char *) "days", NULL
25462 };
25463
25464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25465 {
25466 arg1 = (int)(SWIG_As_int(obj0));
25467 if (SWIG_arg_fail(1)) SWIG_fail;
25468 }
25469 {
25470 PyThreadState* __tstate = wxPyBeginAllowThreads();
25471 result = wxDateSpan::Days(arg1);
25472
25473 wxPyEndAllowThreads(__tstate);
25474 if (PyErr_Occurred()) SWIG_fail;
25475 }
25476 {
25477 wxDateSpan * resultptr;
25478 resultptr = new wxDateSpan((wxDateSpan &)(result));
25479 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25480 }
25481 return resultobj;
25482 fail:
25483 return NULL;
25484 }
25485
25486
25487 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25488 PyObject *resultobj;
25489 wxDateSpan result;
25490 char *kwnames[] = {
25491 NULL
25492 };
25493
25494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25495 {
25496 PyThreadState* __tstate = wxPyBeginAllowThreads();
25497 result = wxDateSpan::Day();
25498
25499 wxPyEndAllowThreads(__tstate);
25500 if (PyErr_Occurred()) SWIG_fail;
25501 }
25502 {
25503 wxDateSpan * resultptr;
25504 resultptr = new wxDateSpan((wxDateSpan &)(result));
25505 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25506 }
25507 return resultobj;
25508 fail:
25509 return NULL;
25510 }
25511
25512
25513 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25514 PyObject *resultobj;
25515 int arg1 ;
25516 wxDateSpan result;
25517 PyObject * obj0 = 0 ;
25518 char *kwnames[] = {
25519 (char *) "weeks", NULL
25520 };
25521
25522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25523 {
25524 arg1 = (int)(SWIG_As_int(obj0));
25525 if (SWIG_arg_fail(1)) SWIG_fail;
25526 }
25527 {
25528 PyThreadState* __tstate = wxPyBeginAllowThreads();
25529 result = wxDateSpan::Weeks(arg1);
25530
25531 wxPyEndAllowThreads(__tstate);
25532 if (PyErr_Occurred()) SWIG_fail;
25533 }
25534 {
25535 wxDateSpan * resultptr;
25536 resultptr = new wxDateSpan((wxDateSpan &)(result));
25537 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25538 }
25539 return resultobj;
25540 fail:
25541 return NULL;
25542 }
25543
25544
25545 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25546 PyObject *resultobj;
25547 wxDateSpan result;
25548 char *kwnames[] = {
25549 NULL
25550 };
25551
25552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25553 {
25554 PyThreadState* __tstate = wxPyBeginAllowThreads();
25555 result = wxDateSpan::Week();
25556
25557 wxPyEndAllowThreads(__tstate);
25558 if (PyErr_Occurred()) SWIG_fail;
25559 }
25560 {
25561 wxDateSpan * resultptr;
25562 resultptr = new wxDateSpan((wxDateSpan &)(result));
25563 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25564 }
25565 return resultobj;
25566 fail:
25567 return NULL;
25568 }
25569
25570
25571 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25572 PyObject *resultobj;
25573 int arg1 ;
25574 wxDateSpan result;
25575 PyObject * obj0 = 0 ;
25576 char *kwnames[] = {
25577 (char *) "mon", NULL
25578 };
25579
25580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25581 {
25582 arg1 = (int)(SWIG_As_int(obj0));
25583 if (SWIG_arg_fail(1)) SWIG_fail;
25584 }
25585 {
25586 PyThreadState* __tstate = wxPyBeginAllowThreads();
25587 result = wxDateSpan::Months(arg1);
25588
25589 wxPyEndAllowThreads(__tstate);
25590 if (PyErr_Occurred()) SWIG_fail;
25591 }
25592 {
25593 wxDateSpan * resultptr;
25594 resultptr = new wxDateSpan((wxDateSpan &)(result));
25595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25596 }
25597 return resultobj;
25598 fail:
25599 return NULL;
25600 }
25601
25602
25603 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25604 PyObject *resultobj;
25605 wxDateSpan result;
25606 char *kwnames[] = {
25607 NULL
25608 };
25609
25610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25611 {
25612 PyThreadState* __tstate = wxPyBeginAllowThreads();
25613 result = wxDateSpan::Month();
25614
25615 wxPyEndAllowThreads(__tstate);
25616 if (PyErr_Occurred()) SWIG_fail;
25617 }
25618 {
25619 wxDateSpan * resultptr;
25620 resultptr = new wxDateSpan((wxDateSpan &)(result));
25621 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25622 }
25623 return resultobj;
25624 fail:
25625 return NULL;
25626 }
25627
25628
25629 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25630 PyObject *resultobj;
25631 int arg1 ;
25632 wxDateSpan result;
25633 PyObject * obj0 = 0 ;
25634 char *kwnames[] = {
25635 (char *) "years", NULL
25636 };
25637
25638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25639 {
25640 arg1 = (int)(SWIG_As_int(obj0));
25641 if (SWIG_arg_fail(1)) SWIG_fail;
25642 }
25643 {
25644 PyThreadState* __tstate = wxPyBeginAllowThreads();
25645 result = wxDateSpan::Years(arg1);
25646
25647 wxPyEndAllowThreads(__tstate);
25648 if (PyErr_Occurred()) SWIG_fail;
25649 }
25650 {
25651 wxDateSpan * resultptr;
25652 resultptr = new wxDateSpan((wxDateSpan &)(result));
25653 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25654 }
25655 return resultobj;
25656 fail:
25657 return NULL;
25658 }
25659
25660
25661 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25662 PyObject *resultobj;
25663 wxDateSpan result;
25664 char *kwnames[] = {
25665 NULL
25666 };
25667
25668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25669 {
25670 PyThreadState* __tstate = wxPyBeginAllowThreads();
25671 result = wxDateSpan::Year();
25672
25673 wxPyEndAllowThreads(__tstate);
25674 if (PyErr_Occurred()) SWIG_fail;
25675 }
25676 {
25677 wxDateSpan * resultptr;
25678 resultptr = new wxDateSpan((wxDateSpan &)(result));
25679 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25680 }
25681 return resultobj;
25682 fail:
25683 return NULL;
25684 }
25685
25686
25687 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25688 PyObject *resultobj;
25689 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25690 int arg2 ;
25691 wxDateSpan *result;
25692 PyObject * obj0 = 0 ;
25693 PyObject * obj1 = 0 ;
25694 char *kwnames[] = {
25695 (char *) "self",(char *) "n", NULL
25696 };
25697
25698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25700 if (SWIG_arg_fail(1)) SWIG_fail;
25701 {
25702 arg2 = (int)(SWIG_As_int(obj1));
25703 if (SWIG_arg_fail(2)) SWIG_fail;
25704 }
25705 {
25706 PyThreadState* __tstate = wxPyBeginAllowThreads();
25707 {
25708 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25709 result = (wxDateSpan *) &_result_ref;
25710 }
25711
25712 wxPyEndAllowThreads(__tstate);
25713 if (PyErr_Occurred()) SWIG_fail;
25714 }
25715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25716 return resultobj;
25717 fail:
25718 return NULL;
25719 }
25720
25721
25722 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25723 PyObject *resultobj;
25724 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25725 int arg2 ;
25726 wxDateSpan *result;
25727 PyObject * obj0 = 0 ;
25728 PyObject * obj1 = 0 ;
25729 char *kwnames[] = {
25730 (char *) "self",(char *) "n", NULL
25731 };
25732
25733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25735 if (SWIG_arg_fail(1)) SWIG_fail;
25736 {
25737 arg2 = (int)(SWIG_As_int(obj1));
25738 if (SWIG_arg_fail(2)) SWIG_fail;
25739 }
25740 {
25741 PyThreadState* __tstate = wxPyBeginAllowThreads();
25742 {
25743 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25744 result = (wxDateSpan *) &_result_ref;
25745 }
25746
25747 wxPyEndAllowThreads(__tstate);
25748 if (PyErr_Occurred()) SWIG_fail;
25749 }
25750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25751 return resultobj;
25752 fail:
25753 return NULL;
25754 }
25755
25756
25757 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25758 PyObject *resultobj;
25759 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25760 int arg2 ;
25761 wxDateSpan *result;
25762 PyObject * obj0 = 0 ;
25763 PyObject * obj1 = 0 ;
25764 char *kwnames[] = {
25765 (char *) "self",(char *) "n", NULL
25766 };
25767
25768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25770 if (SWIG_arg_fail(1)) SWIG_fail;
25771 {
25772 arg2 = (int)(SWIG_As_int(obj1));
25773 if (SWIG_arg_fail(2)) SWIG_fail;
25774 }
25775 {
25776 PyThreadState* __tstate = wxPyBeginAllowThreads();
25777 {
25778 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25779 result = (wxDateSpan *) &_result_ref;
25780 }
25781
25782 wxPyEndAllowThreads(__tstate);
25783 if (PyErr_Occurred()) SWIG_fail;
25784 }
25785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25786 return resultobj;
25787 fail:
25788 return NULL;
25789 }
25790
25791
25792 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25793 PyObject *resultobj;
25794 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25795 int arg2 ;
25796 wxDateSpan *result;
25797 PyObject * obj0 = 0 ;
25798 PyObject * obj1 = 0 ;
25799 char *kwnames[] = {
25800 (char *) "self",(char *) "n", NULL
25801 };
25802
25803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25805 if (SWIG_arg_fail(1)) SWIG_fail;
25806 {
25807 arg2 = (int)(SWIG_As_int(obj1));
25808 if (SWIG_arg_fail(2)) SWIG_fail;
25809 }
25810 {
25811 PyThreadState* __tstate = wxPyBeginAllowThreads();
25812 {
25813 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25814 result = (wxDateSpan *) &_result_ref;
25815 }
25816
25817 wxPyEndAllowThreads(__tstate);
25818 if (PyErr_Occurred()) SWIG_fail;
25819 }
25820 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25828 PyObject *resultobj;
25829 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25830 int result;
25831 PyObject * obj0 = 0 ;
25832 char *kwnames[] = {
25833 (char *) "self", NULL
25834 };
25835
25836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25838 if (SWIG_arg_fail(1)) SWIG_fail;
25839 {
25840 PyThreadState* __tstate = wxPyBeginAllowThreads();
25841 result = (int)((wxDateSpan const *)arg1)->GetYears();
25842
25843 wxPyEndAllowThreads(__tstate);
25844 if (PyErr_Occurred()) SWIG_fail;
25845 }
25846 {
25847 resultobj = SWIG_From_int((int)(result));
25848 }
25849 return resultobj;
25850 fail:
25851 return NULL;
25852 }
25853
25854
25855 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25856 PyObject *resultobj;
25857 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25858 int result;
25859 PyObject * obj0 = 0 ;
25860 char *kwnames[] = {
25861 (char *) "self", NULL
25862 };
25863
25864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25866 if (SWIG_arg_fail(1)) SWIG_fail;
25867 {
25868 PyThreadState* __tstate = wxPyBeginAllowThreads();
25869 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25870
25871 wxPyEndAllowThreads(__tstate);
25872 if (PyErr_Occurred()) SWIG_fail;
25873 }
25874 {
25875 resultobj = SWIG_From_int((int)(result));
25876 }
25877 return resultobj;
25878 fail:
25879 return NULL;
25880 }
25881
25882
25883 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25884 PyObject *resultobj;
25885 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25886 int result;
25887 PyObject * obj0 = 0 ;
25888 char *kwnames[] = {
25889 (char *) "self", NULL
25890 };
25891
25892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25894 if (SWIG_arg_fail(1)) SWIG_fail;
25895 {
25896 PyThreadState* __tstate = wxPyBeginAllowThreads();
25897 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25898
25899 wxPyEndAllowThreads(__tstate);
25900 if (PyErr_Occurred()) SWIG_fail;
25901 }
25902 {
25903 resultobj = SWIG_From_int((int)(result));
25904 }
25905 return resultobj;
25906 fail:
25907 return NULL;
25908 }
25909
25910
25911 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25912 PyObject *resultobj;
25913 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25914 int result;
25915 PyObject * obj0 = 0 ;
25916 char *kwnames[] = {
25917 (char *) "self", NULL
25918 };
25919
25920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25922 if (SWIG_arg_fail(1)) SWIG_fail;
25923 {
25924 PyThreadState* __tstate = wxPyBeginAllowThreads();
25925 result = (int)((wxDateSpan const *)arg1)->GetDays();
25926
25927 wxPyEndAllowThreads(__tstate);
25928 if (PyErr_Occurred()) SWIG_fail;
25929 }
25930 {
25931 resultobj = SWIG_From_int((int)(result));
25932 }
25933 return resultobj;
25934 fail:
25935 return NULL;
25936 }
25937
25938
25939 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25940 PyObject *resultobj;
25941 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25942 int result;
25943 PyObject * obj0 = 0 ;
25944 char *kwnames[] = {
25945 (char *) "self", NULL
25946 };
25947
25948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25950 if (SWIG_arg_fail(1)) SWIG_fail;
25951 {
25952 PyThreadState* __tstate = wxPyBeginAllowThreads();
25953 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25954
25955 wxPyEndAllowThreads(__tstate);
25956 if (PyErr_Occurred()) SWIG_fail;
25957 }
25958 {
25959 resultobj = SWIG_From_int((int)(result));
25960 }
25961 return resultobj;
25962 fail:
25963 return NULL;
25964 }
25965
25966
25967 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25968 PyObject *resultobj;
25969 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25970 wxDateSpan *arg2 = 0 ;
25971 wxDateSpan *result;
25972 PyObject * obj0 = 0 ;
25973 PyObject * obj1 = 0 ;
25974 char *kwnames[] = {
25975 (char *) "self",(char *) "other", NULL
25976 };
25977
25978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25980 if (SWIG_arg_fail(1)) SWIG_fail;
25981 {
25982 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25983 if (SWIG_arg_fail(2)) SWIG_fail;
25984 if (arg2 == NULL) {
25985 SWIG_null_ref("wxDateSpan");
25986 }
25987 if (SWIG_arg_fail(2)) SWIG_fail;
25988 }
25989 {
25990 PyThreadState* __tstate = wxPyBeginAllowThreads();
25991 {
25992 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25993 result = (wxDateSpan *) &_result_ref;
25994 }
25995
25996 wxPyEndAllowThreads(__tstate);
25997 if (PyErr_Occurred()) SWIG_fail;
25998 }
25999 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26000 return resultobj;
26001 fail:
26002 return NULL;
26003 }
26004
26005
26006 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
26007 PyObject *resultobj;
26008 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26009 wxDateSpan *arg2 = 0 ;
26010 wxDateSpan *result;
26011 PyObject * obj0 = 0 ;
26012 PyObject * obj1 = 0 ;
26013 char *kwnames[] = {
26014 (char *) "self",(char *) "other", NULL
26015 };
26016
26017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
26018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26019 if (SWIG_arg_fail(1)) SWIG_fail;
26020 {
26021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26022 if (SWIG_arg_fail(2)) SWIG_fail;
26023 if (arg2 == NULL) {
26024 SWIG_null_ref("wxDateSpan");
26025 }
26026 if (SWIG_arg_fail(2)) SWIG_fail;
26027 }
26028 {
26029 PyThreadState* __tstate = wxPyBeginAllowThreads();
26030 {
26031 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26032 result = (wxDateSpan *) &_result_ref;
26033 }
26034
26035 wxPyEndAllowThreads(__tstate);
26036 if (PyErr_Occurred()) SWIG_fail;
26037 }
26038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26039 return resultobj;
26040 fail:
26041 return NULL;
26042 }
26043
26044
26045 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
26046 PyObject *resultobj;
26047 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26048 wxDateSpan *result;
26049 PyObject * obj0 = 0 ;
26050 char *kwnames[] = {
26051 (char *) "self", NULL
26052 };
26053
26054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26056 if (SWIG_arg_fail(1)) SWIG_fail;
26057 {
26058 PyThreadState* __tstate = wxPyBeginAllowThreads();
26059 {
26060 wxDateSpan &_result_ref = (arg1)->Neg();
26061 result = (wxDateSpan *) &_result_ref;
26062 }
26063
26064 wxPyEndAllowThreads(__tstate);
26065 if (PyErr_Occurred()) SWIG_fail;
26066 }
26067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26068 return resultobj;
26069 fail:
26070 return NULL;
26071 }
26072
26073
26074 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26075 PyObject *resultobj;
26076 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26077 int arg2 ;
26078 wxDateSpan *result;
26079 PyObject * obj0 = 0 ;
26080 PyObject * obj1 = 0 ;
26081 char *kwnames[] = {
26082 (char *) "self",(char *) "factor", NULL
26083 };
26084
26085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26087 if (SWIG_arg_fail(1)) SWIG_fail;
26088 {
26089 arg2 = (int)(SWIG_As_int(obj1));
26090 if (SWIG_arg_fail(2)) SWIG_fail;
26091 }
26092 {
26093 PyThreadState* __tstate = wxPyBeginAllowThreads();
26094 {
26095 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26096 result = (wxDateSpan *) &_result_ref;
26097 }
26098
26099 wxPyEndAllowThreads(__tstate);
26100 if (PyErr_Occurred()) SWIG_fail;
26101 }
26102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26103 return resultobj;
26104 fail:
26105 return NULL;
26106 }
26107
26108
26109 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26110 PyObject *resultobj;
26111 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26112 wxDateSpan *arg2 = 0 ;
26113 wxDateSpan *result;
26114 PyObject * obj0 = 0 ;
26115 PyObject * obj1 = 0 ;
26116 char *kwnames[] = {
26117 (char *) "self",(char *) "other", NULL
26118 };
26119
26120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26122 if (SWIG_arg_fail(1)) SWIG_fail;
26123 {
26124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26125 if (SWIG_arg_fail(2)) SWIG_fail;
26126 if (arg2 == NULL) {
26127 SWIG_null_ref("wxDateSpan");
26128 }
26129 if (SWIG_arg_fail(2)) SWIG_fail;
26130 }
26131 {
26132 PyThreadState* __tstate = wxPyBeginAllowThreads();
26133 {
26134 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26135 result = (wxDateSpan *) &_result_ref;
26136 }
26137
26138 wxPyEndAllowThreads(__tstate);
26139 if (PyErr_Occurred()) SWIG_fail;
26140 }
26141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26142 return resultobj;
26143 fail:
26144 return NULL;
26145 }
26146
26147
26148 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26149 PyObject *resultobj;
26150 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26151 wxDateSpan *arg2 = 0 ;
26152 wxDateSpan *result;
26153 PyObject * obj0 = 0 ;
26154 PyObject * obj1 = 0 ;
26155 char *kwnames[] = {
26156 (char *) "self",(char *) "other", NULL
26157 };
26158
26159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26161 if (SWIG_arg_fail(1)) SWIG_fail;
26162 {
26163 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26164 if (SWIG_arg_fail(2)) SWIG_fail;
26165 if (arg2 == NULL) {
26166 SWIG_null_ref("wxDateSpan");
26167 }
26168 if (SWIG_arg_fail(2)) SWIG_fail;
26169 }
26170 {
26171 PyThreadState* __tstate = wxPyBeginAllowThreads();
26172 {
26173 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26174 result = (wxDateSpan *) &_result_ref;
26175 }
26176
26177 wxPyEndAllowThreads(__tstate);
26178 if (PyErr_Occurred()) SWIG_fail;
26179 }
26180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26181 return resultobj;
26182 fail:
26183 return NULL;
26184 }
26185
26186
26187 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26188 PyObject *resultobj;
26189 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26190 wxDateSpan *result;
26191 PyObject * obj0 = 0 ;
26192 char *kwnames[] = {
26193 (char *) "self", NULL
26194 };
26195
26196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26198 if (SWIG_arg_fail(1)) SWIG_fail;
26199 {
26200 PyThreadState* __tstate = wxPyBeginAllowThreads();
26201 {
26202 wxDateSpan &_result_ref = (arg1)->operator -();
26203 result = (wxDateSpan *) &_result_ref;
26204 }
26205
26206 wxPyEndAllowThreads(__tstate);
26207 if (PyErr_Occurred()) SWIG_fail;
26208 }
26209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26210 return resultobj;
26211 fail:
26212 return NULL;
26213 }
26214
26215
26216 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26217 PyObject *resultobj;
26218 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26219 int arg2 ;
26220 wxDateSpan *result;
26221 PyObject * obj0 = 0 ;
26222 PyObject * obj1 = 0 ;
26223 char *kwnames[] = {
26224 (char *) "self",(char *) "factor", NULL
26225 };
26226
26227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26229 if (SWIG_arg_fail(1)) SWIG_fail;
26230 {
26231 arg2 = (int)(SWIG_As_int(obj1));
26232 if (SWIG_arg_fail(2)) SWIG_fail;
26233 }
26234 {
26235 PyThreadState* __tstate = wxPyBeginAllowThreads();
26236 {
26237 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26238 result = (wxDateSpan *) &_result_ref;
26239 }
26240
26241 wxPyEndAllowThreads(__tstate);
26242 if (PyErr_Occurred()) SWIG_fail;
26243 }
26244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26245 return resultobj;
26246 fail:
26247 return NULL;
26248 }
26249
26250
26251 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26252 PyObject *resultobj;
26253 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26254 wxDateSpan *arg2 = 0 ;
26255 wxDateSpan result;
26256 PyObject * obj0 = 0 ;
26257 PyObject * obj1 = 0 ;
26258 char *kwnames[] = {
26259 (char *) "self",(char *) "other", NULL
26260 };
26261
26262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26264 if (SWIG_arg_fail(1)) SWIG_fail;
26265 {
26266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26267 if (SWIG_arg_fail(2)) SWIG_fail;
26268 if (arg2 == NULL) {
26269 SWIG_null_ref("wxDateSpan");
26270 }
26271 if (SWIG_arg_fail(2)) SWIG_fail;
26272 }
26273 {
26274 PyThreadState* __tstate = wxPyBeginAllowThreads();
26275 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26276
26277 wxPyEndAllowThreads(__tstate);
26278 if (PyErr_Occurred()) SWIG_fail;
26279 }
26280 {
26281 wxDateSpan * resultptr;
26282 resultptr = new wxDateSpan((wxDateSpan &)(result));
26283 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26284 }
26285 return resultobj;
26286 fail:
26287 return NULL;
26288 }
26289
26290
26291 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26292 PyObject *resultobj;
26293 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26294 wxDateSpan *arg2 = 0 ;
26295 wxDateSpan result;
26296 PyObject * obj0 = 0 ;
26297 PyObject * obj1 = 0 ;
26298 char *kwnames[] = {
26299 (char *) "self",(char *) "other", NULL
26300 };
26301
26302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26304 if (SWIG_arg_fail(1)) SWIG_fail;
26305 {
26306 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26307 if (SWIG_arg_fail(2)) SWIG_fail;
26308 if (arg2 == NULL) {
26309 SWIG_null_ref("wxDateSpan");
26310 }
26311 if (SWIG_arg_fail(2)) SWIG_fail;
26312 }
26313 {
26314 PyThreadState* __tstate = wxPyBeginAllowThreads();
26315 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26316
26317 wxPyEndAllowThreads(__tstate);
26318 if (PyErr_Occurred()) SWIG_fail;
26319 }
26320 {
26321 wxDateSpan * resultptr;
26322 resultptr = new wxDateSpan((wxDateSpan &)(result));
26323 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26324 }
26325 return resultobj;
26326 fail:
26327 return NULL;
26328 }
26329
26330
26331 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26332 PyObject *resultobj;
26333 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26334 int arg2 ;
26335 wxDateSpan result;
26336 PyObject * obj0 = 0 ;
26337 PyObject * obj1 = 0 ;
26338 char *kwnames[] = {
26339 (char *) "self",(char *) "n", NULL
26340 };
26341
26342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26344 if (SWIG_arg_fail(1)) SWIG_fail;
26345 {
26346 arg2 = (int)(SWIG_As_int(obj1));
26347 if (SWIG_arg_fail(2)) SWIG_fail;
26348 }
26349 {
26350 PyThreadState* __tstate = wxPyBeginAllowThreads();
26351 result = wxDateSpan___mul__(arg1,arg2);
26352
26353 wxPyEndAllowThreads(__tstate);
26354 if (PyErr_Occurred()) SWIG_fail;
26355 }
26356 {
26357 wxDateSpan * resultptr;
26358 resultptr = new wxDateSpan((wxDateSpan &)(result));
26359 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26360 }
26361 return resultobj;
26362 fail:
26363 return NULL;
26364 }
26365
26366
26367 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26368 PyObject *resultobj;
26369 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26370 int arg2 ;
26371 wxDateSpan result;
26372 PyObject * obj0 = 0 ;
26373 PyObject * obj1 = 0 ;
26374 char *kwnames[] = {
26375 (char *) "self",(char *) "n", NULL
26376 };
26377
26378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26380 if (SWIG_arg_fail(1)) SWIG_fail;
26381 {
26382 arg2 = (int)(SWIG_As_int(obj1));
26383 if (SWIG_arg_fail(2)) SWIG_fail;
26384 }
26385 {
26386 PyThreadState* __tstate = wxPyBeginAllowThreads();
26387 result = wxDateSpan___rmul__(arg1,arg2);
26388
26389 wxPyEndAllowThreads(__tstate);
26390 if (PyErr_Occurred()) SWIG_fail;
26391 }
26392 {
26393 wxDateSpan * resultptr;
26394 resultptr = new wxDateSpan((wxDateSpan &)(result));
26395 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26396 }
26397 return resultobj;
26398 fail:
26399 return NULL;
26400 }
26401
26402
26403 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26404 PyObject *resultobj;
26405 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26406 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26407 bool result;
26408 PyObject * obj0 = 0 ;
26409 PyObject * obj1 = 0 ;
26410 char *kwnames[] = {
26411 (char *) "self",(char *) "other", NULL
26412 };
26413
26414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26416 if (SWIG_arg_fail(1)) SWIG_fail;
26417 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26418 if (SWIG_arg_fail(2)) SWIG_fail;
26419 {
26420 PyThreadState* __tstate = wxPyBeginAllowThreads();
26421 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26422
26423 wxPyEndAllowThreads(__tstate);
26424 if (PyErr_Occurred()) SWIG_fail;
26425 }
26426 {
26427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26428 }
26429 return resultobj;
26430 fail:
26431 return NULL;
26432 }
26433
26434
26435 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26436 PyObject *resultobj;
26437 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26438 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26439 bool result;
26440 PyObject * obj0 = 0 ;
26441 PyObject * obj1 = 0 ;
26442 char *kwnames[] = {
26443 (char *) "self",(char *) "other", NULL
26444 };
26445
26446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26448 if (SWIG_arg_fail(1)) SWIG_fail;
26449 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26450 if (SWIG_arg_fail(2)) SWIG_fail;
26451 {
26452 PyThreadState* __tstate = wxPyBeginAllowThreads();
26453 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26454
26455 wxPyEndAllowThreads(__tstate);
26456 if (PyErr_Occurred()) SWIG_fail;
26457 }
26458 {
26459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26460 }
26461 return resultobj;
26462 fail:
26463 return NULL;
26464 }
26465
26466
26467 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26468 PyObject *obj;
26469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26470 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26471 Py_INCREF(obj);
26472 return Py_BuildValue((char *)"");
26473 }
26474 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26475 PyObject *resultobj;
26476 long result;
26477 char *kwnames[] = {
26478 NULL
26479 };
26480
26481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26482 {
26483 PyThreadState* __tstate = wxPyBeginAllowThreads();
26484 result = (long)wxGetLocalTime();
26485
26486 wxPyEndAllowThreads(__tstate);
26487 if (PyErr_Occurred()) SWIG_fail;
26488 }
26489 {
26490 resultobj = SWIG_From_long((long)(result));
26491 }
26492 return resultobj;
26493 fail:
26494 return NULL;
26495 }
26496
26497
26498 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26499 PyObject *resultobj;
26500 long result;
26501 char *kwnames[] = {
26502 NULL
26503 };
26504
26505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 result = (long)wxGetUTCTime();
26509
26510 wxPyEndAllowThreads(__tstate);
26511 if (PyErr_Occurred()) SWIG_fail;
26512 }
26513 {
26514 resultobj = SWIG_From_long((long)(result));
26515 }
26516 return resultobj;
26517 fail:
26518 return NULL;
26519 }
26520
26521
26522 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26523 PyObject *resultobj;
26524 long result;
26525 char *kwnames[] = {
26526 NULL
26527 };
26528
26529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26530 {
26531 PyThreadState* __tstate = wxPyBeginAllowThreads();
26532 result = (long)wxGetCurrentTime();
26533
26534 wxPyEndAllowThreads(__tstate);
26535 if (PyErr_Occurred()) SWIG_fail;
26536 }
26537 {
26538 resultobj = SWIG_From_long((long)(result));
26539 }
26540 return resultobj;
26541 fail:
26542 return NULL;
26543 }
26544
26545
26546 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26547 PyObject *resultobj;
26548 wxLongLong result;
26549 char *kwnames[] = {
26550 NULL
26551 };
26552
26553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26554 {
26555 PyThreadState* __tstate = wxPyBeginAllowThreads();
26556 result = wxGetLocalTimeMillis();
26557
26558 wxPyEndAllowThreads(__tstate);
26559 if (PyErr_Occurred()) SWIG_fail;
26560 }
26561 {
26562 PyObject *hi, *lo, *shifter, *shifted;
26563 hi = PyLong_FromLong( (&result)->GetHi() );
26564 lo = PyLong_FromLong( (&result)->GetLo() );
26565 shifter = PyLong_FromLong(32);
26566 shifted = PyNumber_Lshift(hi, shifter);
26567 resultobj = PyNumber_Or(shifted, lo);
26568 Py_DECREF(hi);
26569 Py_DECREF(lo);
26570 Py_DECREF(shifter);
26571 Py_DECREF(shifted);
26572 }
26573 return resultobj;
26574 fail:
26575 return NULL;
26576 }
26577
26578
26579 static int _wrap_DefaultDateTime_set(PyObject *) {
26580 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26581 return 1;
26582 }
26583
26584
26585 static PyObject *_wrap_DefaultDateTime_get(void) {
26586 PyObject *pyobj;
26587
26588 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26589 return pyobj;
26590 }
26591
26592
26593 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26594 PyObject *resultobj;
26595 wxDataFormatId arg1 ;
26596 wxDataFormat *result;
26597 PyObject * obj0 = 0 ;
26598 char *kwnames[] = {
26599 (char *) "type", NULL
26600 };
26601
26602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26603 {
26604 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26605 if (SWIG_arg_fail(1)) SWIG_fail;
26606 }
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26610
26611 wxPyEndAllowThreads(__tstate);
26612 if (PyErr_Occurred()) SWIG_fail;
26613 }
26614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26615 return resultobj;
26616 fail:
26617 return NULL;
26618 }
26619
26620
26621 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26622 PyObject *resultobj;
26623 wxString *arg1 = 0 ;
26624 wxDataFormat *result;
26625 bool temp1 = false ;
26626 PyObject * obj0 = 0 ;
26627 char *kwnames[] = {
26628 (char *) "format", NULL
26629 };
26630
26631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26632 {
26633 arg1 = wxString_in_helper(obj0);
26634 if (arg1 == NULL) SWIG_fail;
26635 temp1 = true;
26636 }
26637 {
26638 PyThreadState* __tstate = wxPyBeginAllowThreads();
26639 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26640
26641 wxPyEndAllowThreads(__tstate);
26642 if (PyErr_Occurred()) SWIG_fail;
26643 }
26644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26645 {
26646 if (temp1)
26647 delete arg1;
26648 }
26649 return resultobj;
26650 fail:
26651 {
26652 if (temp1)
26653 delete arg1;
26654 }
26655 return NULL;
26656 }
26657
26658
26659 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26660 PyObject *resultobj;
26661 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26662 PyObject * obj0 = 0 ;
26663 char *kwnames[] = {
26664 (char *) "self", NULL
26665 };
26666
26667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26669 if (SWIG_arg_fail(1)) SWIG_fail;
26670 {
26671 PyThreadState* __tstate = wxPyBeginAllowThreads();
26672 delete arg1;
26673
26674 wxPyEndAllowThreads(__tstate);
26675 if (PyErr_Occurred()) SWIG_fail;
26676 }
26677 Py_INCREF(Py_None); resultobj = Py_None;
26678 return resultobj;
26679 fail:
26680 return NULL;
26681 }
26682
26683
26684 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26685 PyObject *resultobj;
26686 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26687 wxDataFormatId arg2 ;
26688 bool result;
26689 PyObject * obj0 = 0 ;
26690 PyObject * obj1 = 0 ;
26691
26692 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26694 if (SWIG_arg_fail(1)) SWIG_fail;
26695 {
26696 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26697 if (SWIG_arg_fail(2)) SWIG_fail;
26698 }
26699 {
26700 PyThreadState* __tstate = wxPyBeginAllowThreads();
26701 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26702
26703 wxPyEndAllowThreads(__tstate);
26704 if (PyErr_Occurred()) SWIG_fail;
26705 }
26706 {
26707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26708 }
26709 return resultobj;
26710 fail:
26711 return NULL;
26712 }
26713
26714
26715 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26716 PyObject *resultobj;
26717 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26718 wxDataFormatId arg2 ;
26719 bool result;
26720 PyObject * obj0 = 0 ;
26721 PyObject * obj1 = 0 ;
26722
26723 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26725 if (SWIG_arg_fail(1)) SWIG_fail;
26726 {
26727 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26728 if (SWIG_arg_fail(2)) SWIG_fail;
26729 }
26730 {
26731 PyThreadState* __tstate = wxPyBeginAllowThreads();
26732 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26733
26734 wxPyEndAllowThreads(__tstate);
26735 if (PyErr_Occurred()) SWIG_fail;
26736 }
26737 {
26738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26739 }
26740 return resultobj;
26741 fail:
26742 return NULL;
26743 }
26744
26745
26746 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26747 PyObject *resultobj;
26748 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26749 wxDataFormat *arg2 = 0 ;
26750 bool result;
26751 PyObject * obj0 = 0 ;
26752 PyObject * obj1 = 0 ;
26753
26754 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26756 if (SWIG_arg_fail(1)) SWIG_fail;
26757 {
26758 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26759 if (SWIG_arg_fail(2)) SWIG_fail;
26760 if (arg2 == NULL) {
26761 SWIG_null_ref("wxDataFormat");
26762 }
26763 if (SWIG_arg_fail(2)) SWIG_fail;
26764 }
26765 {
26766 PyThreadState* __tstate = wxPyBeginAllowThreads();
26767 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26768
26769 wxPyEndAllowThreads(__tstate);
26770 if (PyErr_Occurred()) SWIG_fail;
26771 }
26772 {
26773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26774 }
26775 return resultobj;
26776 fail:
26777 return NULL;
26778 }
26779
26780
26781 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26782 int argc;
26783 PyObject *argv[3];
26784 int ii;
26785
26786 argc = PyObject_Length(args);
26787 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26788 argv[ii] = PyTuple_GetItem(args,ii);
26789 }
26790 if (argc == 2) {
26791 int _v;
26792 {
26793 void *ptr;
26794 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26795 _v = 0;
26796 PyErr_Clear();
26797 } else {
26798 _v = 1;
26799 }
26800 }
26801 if (_v) {
26802 {
26803 void *ptr = 0;
26804 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26805 _v = 0;
26806 PyErr_Clear();
26807 } else {
26808 _v = (ptr != 0);
26809 }
26810 }
26811 if (_v) {
26812 return _wrap_DataFormat___eq____SWIG_1(self,args);
26813 }
26814 }
26815 }
26816 if (argc == 2) {
26817 int _v;
26818 {
26819 void *ptr;
26820 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26821 _v = 0;
26822 PyErr_Clear();
26823 } else {
26824 _v = 1;
26825 }
26826 }
26827 if (_v) {
26828 _v = SWIG_Check_int(argv[1]);
26829 if (_v) {
26830 return _wrap_DataFormat___eq____SWIG_0(self,args);
26831 }
26832 }
26833 }
26834
26835 Py_INCREF(Py_NotImplemented);
26836 return Py_NotImplemented;
26837 }
26838
26839
26840 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26841 PyObject *resultobj;
26842 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26843 wxDataFormat *arg2 = 0 ;
26844 bool result;
26845 PyObject * obj0 = 0 ;
26846 PyObject * obj1 = 0 ;
26847
26848 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26850 if (SWIG_arg_fail(1)) SWIG_fail;
26851 {
26852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26853 if (SWIG_arg_fail(2)) SWIG_fail;
26854 if (arg2 == NULL) {
26855 SWIG_null_ref("wxDataFormat");
26856 }
26857 if (SWIG_arg_fail(2)) SWIG_fail;
26858 }
26859 {
26860 PyThreadState* __tstate = wxPyBeginAllowThreads();
26861 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26862
26863 wxPyEndAllowThreads(__tstate);
26864 if (PyErr_Occurred()) SWIG_fail;
26865 }
26866 {
26867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26868 }
26869 return resultobj;
26870 fail:
26871 return NULL;
26872 }
26873
26874
26875 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26876 int argc;
26877 PyObject *argv[3];
26878 int ii;
26879
26880 argc = PyObject_Length(args);
26881 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26882 argv[ii] = PyTuple_GetItem(args,ii);
26883 }
26884 if (argc == 2) {
26885 int _v;
26886 {
26887 void *ptr;
26888 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26889 _v = 0;
26890 PyErr_Clear();
26891 } else {
26892 _v = 1;
26893 }
26894 }
26895 if (_v) {
26896 {
26897 void *ptr = 0;
26898 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26899 _v = 0;
26900 PyErr_Clear();
26901 } else {
26902 _v = (ptr != 0);
26903 }
26904 }
26905 if (_v) {
26906 return _wrap_DataFormat___ne____SWIG_1(self,args);
26907 }
26908 }
26909 }
26910 if (argc == 2) {
26911 int _v;
26912 {
26913 void *ptr;
26914 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26915 _v = 0;
26916 PyErr_Clear();
26917 } else {
26918 _v = 1;
26919 }
26920 }
26921 if (_v) {
26922 _v = SWIG_Check_int(argv[1]);
26923 if (_v) {
26924 return _wrap_DataFormat___ne____SWIG_0(self,args);
26925 }
26926 }
26927 }
26928
26929 Py_INCREF(Py_NotImplemented);
26930 return Py_NotImplemented;
26931 }
26932
26933
26934 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26935 PyObject *resultobj;
26936 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26937 wxDataFormatId arg2 ;
26938 PyObject * obj0 = 0 ;
26939 PyObject * obj1 = 0 ;
26940 char *kwnames[] = {
26941 (char *) "self",(char *) "format", NULL
26942 };
26943
26944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26946 if (SWIG_arg_fail(1)) SWIG_fail;
26947 {
26948 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26949 if (SWIG_arg_fail(2)) SWIG_fail;
26950 }
26951 {
26952 PyThreadState* __tstate = wxPyBeginAllowThreads();
26953 (arg1)->SetType((wxDataFormatId )arg2);
26954
26955 wxPyEndAllowThreads(__tstate);
26956 if (PyErr_Occurred()) SWIG_fail;
26957 }
26958 Py_INCREF(Py_None); resultobj = Py_None;
26959 return resultobj;
26960 fail:
26961 return NULL;
26962 }
26963
26964
26965 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26966 PyObject *resultobj;
26967 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26968 wxDataFormatId result;
26969 PyObject * obj0 = 0 ;
26970 char *kwnames[] = {
26971 (char *) "self", NULL
26972 };
26973
26974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26976 if (SWIG_arg_fail(1)) SWIG_fail;
26977 {
26978 PyThreadState* __tstate = wxPyBeginAllowThreads();
26979 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26980
26981 wxPyEndAllowThreads(__tstate);
26982 if (PyErr_Occurred()) SWIG_fail;
26983 }
26984 resultobj = SWIG_From_int((result));
26985 return resultobj;
26986 fail:
26987 return NULL;
26988 }
26989
26990
26991 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26992 PyObject *resultobj;
26993 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26994 wxString result;
26995 PyObject * obj0 = 0 ;
26996 char *kwnames[] = {
26997 (char *) "self", NULL
26998 };
26999
27000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
27001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27002 if (SWIG_arg_fail(1)) SWIG_fail;
27003 {
27004 PyThreadState* __tstate = wxPyBeginAllowThreads();
27005 result = ((wxDataFormat const *)arg1)->GetId();
27006
27007 wxPyEndAllowThreads(__tstate);
27008 if (PyErr_Occurred()) SWIG_fail;
27009 }
27010 {
27011 #if wxUSE_UNICODE
27012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27013 #else
27014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27015 #endif
27016 }
27017 return resultobj;
27018 fail:
27019 return NULL;
27020 }
27021
27022
27023 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
27024 PyObject *resultobj;
27025 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27026 wxString *arg2 = 0 ;
27027 bool temp2 = false ;
27028 PyObject * obj0 = 0 ;
27029 PyObject * obj1 = 0 ;
27030 char *kwnames[] = {
27031 (char *) "self",(char *) "format", NULL
27032 };
27033
27034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
27035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27036 if (SWIG_arg_fail(1)) SWIG_fail;
27037 {
27038 arg2 = wxString_in_helper(obj1);
27039 if (arg2 == NULL) SWIG_fail;
27040 temp2 = true;
27041 }
27042 {
27043 PyThreadState* __tstate = wxPyBeginAllowThreads();
27044 (arg1)->SetId((wxString const &)*arg2);
27045
27046 wxPyEndAllowThreads(__tstate);
27047 if (PyErr_Occurred()) SWIG_fail;
27048 }
27049 Py_INCREF(Py_None); resultobj = Py_None;
27050 {
27051 if (temp2)
27052 delete arg2;
27053 }
27054 return resultobj;
27055 fail:
27056 {
27057 if (temp2)
27058 delete arg2;
27059 }
27060 return NULL;
27061 }
27062
27063
27064 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27065 PyObject *obj;
27066 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27067 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27068 Py_INCREF(obj);
27069 return Py_BuildValue((char *)"");
27070 }
27071 static int _wrap_FormatInvalid_set(PyObject *) {
27072 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27073 return 1;
27074 }
27075
27076
27077 static PyObject *_wrap_FormatInvalid_get(void) {
27078 PyObject *pyobj;
27079
27080 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27081 return pyobj;
27082 }
27083
27084
27085 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27086 PyObject *resultobj;
27087 wxDataObject *arg1 = (wxDataObject *) 0 ;
27088 PyObject * obj0 = 0 ;
27089 char *kwnames[] = {
27090 (char *) "self", NULL
27091 };
27092
27093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27095 if (SWIG_arg_fail(1)) SWIG_fail;
27096 {
27097 PyThreadState* __tstate = wxPyBeginAllowThreads();
27098 delete arg1;
27099
27100 wxPyEndAllowThreads(__tstate);
27101 if (PyErr_Occurred()) SWIG_fail;
27102 }
27103 Py_INCREF(Py_None); resultobj = Py_None;
27104 return resultobj;
27105 fail:
27106 return NULL;
27107 }
27108
27109
27110 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27111 PyObject *resultobj;
27112 wxDataObject *arg1 = (wxDataObject *) 0 ;
27113 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27114 SwigValueWrapper<wxDataFormat > result;
27115 PyObject * obj0 = 0 ;
27116 PyObject * obj1 = 0 ;
27117 char *kwnames[] = {
27118 (char *) "self",(char *) "dir", NULL
27119 };
27120
27121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27123 if (SWIG_arg_fail(1)) SWIG_fail;
27124 if (obj1) {
27125 {
27126 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27127 if (SWIG_arg_fail(2)) SWIG_fail;
27128 }
27129 }
27130 {
27131 PyThreadState* __tstate = wxPyBeginAllowThreads();
27132 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27133
27134 wxPyEndAllowThreads(__tstate);
27135 if (PyErr_Occurred()) SWIG_fail;
27136 }
27137 {
27138 wxDataFormat * resultptr;
27139 resultptr = new wxDataFormat((wxDataFormat &)(result));
27140 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27141 }
27142 return resultobj;
27143 fail:
27144 return NULL;
27145 }
27146
27147
27148 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27149 PyObject *resultobj;
27150 wxDataObject *arg1 = (wxDataObject *) 0 ;
27151 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27152 size_t result;
27153 PyObject * obj0 = 0 ;
27154 PyObject * obj1 = 0 ;
27155 char *kwnames[] = {
27156 (char *) "self",(char *) "dir", NULL
27157 };
27158
27159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27161 if (SWIG_arg_fail(1)) SWIG_fail;
27162 if (obj1) {
27163 {
27164 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27165 if (SWIG_arg_fail(2)) SWIG_fail;
27166 }
27167 }
27168 {
27169 PyThreadState* __tstate = wxPyBeginAllowThreads();
27170 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27171
27172 wxPyEndAllowThreads(__tstate);
27173 if (PyErr_Occurred()) SWIG_fail;
27174 }
27175 {
27176 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27177 }
27178 return resultobj;
27179 fail:
27180 return NULL;
27181 }
27182
27183
27184 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27185 PyObject *resultobj;
27186 wxDataObject *arg1 = (wxDataObject *) 0 ;
27187 wxDataFormat *arg2 = 0 ;
27188 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27189 bool result;
27190 PyObject * obj0 = 0 ;
27191 PyObject * obj1 = 0 ;
27192 PyObject * obj2 = 0 ;
27193 char *kwnames[] = {
27194 (char *) "self",(char *) "format",(char *) "dir", NULL
27195 };
27196
27197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27199 if (SWIG_arg_fail(1)) SWIG_fail;
27200 {
27201 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27202 if (SWIG_arg_fail(2)) SWIG_fail;
27203 if (arg2 == NULL) {
27204 SWIG_null_ref("wxDataFormat");
27205 }
27206 if (SWIG_arg_fail(2)) SWIG_fail;
27207 }
27208 if (obj2) {
27209 {
27210 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27211 if (SWIG_arg_fail(3)) SWIG_fail;
27212 }
27213 }
27214 {
27215 PyThreadState* __tstate = wxPyBeginAllowThreads();
27216 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27217
27218 wxPyEndAllowThreads(__tstate);
27219 if (PyErr_Occurred()) SWIG_fail;
27220 }
27221 {
27222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27223 }
27224 return resultobj;
27225 fail:
27226 return NULL;
27227 }
27228
27229
27230 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27231 PyObject *resultobj;
27232 wxDataObject *arg1 = (wxDataObject *) 0 ;
27233 wxDataFormat *arg2 = 0 ;
27234 size_t result;
27235 PyObject * obj0 = 0 ;
27236 PyObject * obj1 = 0 ;
27237 char *kwnames[] = {
27238 (char *) "self",(char *) "format", NULL
27239 };
27240
27241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27243 if (SWIG_arg_fail(1)) SWIG_fail;
27244 {
27245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27246 if (SWIG_arg_fail(2)) SWIG_fail;
27247 if (arg2 == NULL) {
27248 SWIG_null_ref("wxDataFormat");
27249 }
27250 if (SWIG_arg_fail(2)) SWIG_fail;
27251 }
27252 {
27253 PyThreadState* __tstate = wxPyBeginAllowThreads();
27254 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27255
27256 wxPyEndAllowThreads(__tstate);
27257 if (PyErr_Occurred()) SWIG_fail;
27258 }
27259 {
27260 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27261 }
27262 return resultobj;
27263 fail:
27264 return NULL;
27265 }
27266
27267
27268 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27269 PyObject *resultobj;
27270 wxDataObject *arg1 = (wxDataObject *) 0 ;
27271 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27272 PyObject *result;
27273 PyObject * obj0 = 0 ;
27274 PyObject * obj1 = 0 ;
27275 char *kwnames[] = {
27276 (char *) "self",(char *) "dir", NULL
27277 };
27278
27279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27281 if (SWIG_arg_fail(1)) SWIG_fail;
27282 if (obj1) {
27283 {
27284 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27285 if (SWIG_arg_fail(2)) SWIG_fail;
27286 }
27287 }
27288 {
27289 PyThreadState* __tstate = wxPyBeginAllowThreads();
27290 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27291
27292 wxPyEndAllowThreads(__tstate);
27293 if (PyErr_Occurred()) SWIG_fail;
27294 }
27295 resultobj = result;
27296 return resultobj;
27297 fail:
27298 return NULL;
27299 }
27300
27301
27302 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27303 PyObject *resultobj;
27304 wxDataObject *arg1 = (wxDataObject *) 0 ;
27305 wxDataFormat *arg2 = 0 ;
27306 PyObject *result;
27307 PyObject * obj0 = 0 ;
27308 PyObject * obj1 = 0 ;
27309 char *kwnames[] = {
27310 (char *) "self",(char *) "format", NULL
27311 };
27312
27313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27315 if (SWIG_arg_fail(1)) SWIG_fail;
27316 {
27317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27318 if (SWIG_arg_fail(2)) SWIG_fail;
27319 if (arg2 == NULL) {
27320 SWIG_null_ref("wxDataFormat");
27321 }
27322 if (SWIG_arg_fail(2)) SWIG_fail;
27323 }
27324 {
27325 PyThreadState* __tstate = wxPyBeginAllowThreads();
27326 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27327
27328 wxPyEndAllowThreads(__tstate);
27329 if (PyErr_Occurred()) SWIG_fail;
27330 }
27331 resultobj = result;
27332 return resultobj;
27333 fail:
27334 return NULL;
27335 }
27336
27337
27338 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27339 PyObject *resultobj;
27340 wxDataObject *arg1 = (wxDataObject *) 0 ;
27341 wxDataFormat *arg2 = 0 ;
27342 PyObject *arg3 = (PyObject *) 0 ;
27343 bool result;
27344 PyObject * obj0 = 0 ;
27345 PyObject * obj1 = 0 ;
27346 PyObject * obj2 = 0 ;
27347 char *kwnames[] = {
27348 (char *) "self",(char *) "format",(char *) "data", NULL
27349 };
27350
27351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27353 if (SWIG_arg_fail(1)) SWIG_fail;
27354 {
27355 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27356 if (SWIG_arg_fail(2)) SWIG_fail;
27357 if (arg2 == NULL) {
27358 SWIG_null_ref("wxDataFormat");
27359 }
27360 if (SWIG_arg_fail(2)) SWIG_fail;
27361 }
27362 arg3 = obj2;
27363 {
27364 PyThreadState* __tstate = wxPyBeginAllowThreads();
27365 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27366
27367 wxPyEndAllowThreads(__tstate);
27368 if (PyErr_Occurred()) SWIG_fail;
27369 }
27370 {
27371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27372 }
27373 return resultobj;
27374 fail:
27375 return NULL;
27376 }
27377
27378
27379 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27380 PyObject *obj;
27381 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27382 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27383 Py_INCREF(obj);
27384 return Py_BuildValue((char *)"");
27385 }
27386 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27387 PyObject *resultobj;
27388 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27389 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27390 wxDataObjectSimple *result;
27391 PyObject * obj0 = 0 ;
27392 char *kwnames[] = {
27393 (char *) "format", NULL
27394 };
27395
27396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27397 if (obj0) {
27398 {
27399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27400 if (SWIG_arg_fail(1)) SWIG_fail;
27401 if (arg1 == NULL) {
27402 SWIG_null_ref("wxDataFormat");
27403 }
27404 if (SWIG_arg_fail(1)) SWIG_fail;
27405 }
27406 }
27407 {
27408 PyThreadState* __tstate = wxPyBeginAllowThreads();
27409 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27410
27411 wxPyEndAllowThreads(__tstate);
27412 if (PyErr_Occurred()) SWIG_fail;
27413 }
27414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27415 return resultobj;
27416 fail:
27417 return NULL;
27418 }
27419
27420
27421 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27422 PyObject *resultobj;
27423 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27424 wxDataFormat *result;
27425 PyObject * obj0 = 0 ;
27426 char *kwnames[] = {
27427 (char *) "self", NULL
27428 };
27429
27430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27432 if (SWIG_arg_fail(1)) SWIG_fail;
27433 {
27434 PyThreadState* __tstate = wxPyBeginAllowThreads();
27435 {
27436 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27437 result = (wxDataFormat *) &_result_ref;
27438 }
27439
27440 wxPyEndAllowThreads(__tstate);
27441 if (PyErr_Occurred()) SWIG_fail;
27442 }
27443 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27444 return resultobj;
27445 fail:
27446 return NULL;
27447 }
27448
27449
27450 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27451 PyObject *resultobj;
27452 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27453 wxDataFormat *arg2 = 0 ;
27454 PyObject * obj0 = 0 ;
27455 PyObject * obj1 = 0 ;
27456 char *kwnames[] = {
27457 (char *) "self",(char *) "format", NULL
27458 };
27459
27460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27462 if (SWIG_arg_fail(1)) SWIG_fail;
27463 {
27464 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27465 if (SWIG_arg_fail(2)) SWIG_fail;
27466 if (arg2 == NULL) {
27467 SWIG_null_ref("wxDataFormat");
27468 }
27469 if (SWIG_arg_fail(2)) SWIG_fail;
27470 }
27471 {
27472 PyThreadState* __tstate = wxPyBeginAllowThreads();
27473 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27474
27475 wxPyEndAllowThreads(__tstate);
27476 if (PyErr_Occurred()) SWIG_fail;
27477 }
27478 Py_INCREF(Py_None); resultobj = Py_None;
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27486 PyObject *resultobj;
27487 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27488 size_t result;
27489 PyObject * obj0 = 0 ;
27490 char *kwnames[] = {
27491 (char *) "self", NULL
27492 };
27493
27494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27496 if (SWIG_arg_fail(1)) SWIG_fail;
27497 {
27498 PyThreadState* __tstate = wxPyBeginAllowThreads();
27499 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27500
27501 wxPyEndAllowThreads(__tstate);
27502 if (PyErr_Occurred()) SWIG_fail;
27503 }
27504 {
27505 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27506 }
27507 return resultobj;
27508 fail:
27509 return NULL;
27510 }
27511
27512
27513 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27514 PyObject *resultobj;
27515 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27516 PyObject *result;
27517 PyObject * obj0 = 0 ;
27518 char *kwnames[] = {
27519 (char *) "self", NULL
27520 };
27521
27522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27524 if (SWIG_arg_fail(1)) SWIG_fail;
27525 {
27526 PyThreadState* __tstate = wxPyBeginAllowThreads();
27527 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27528
27529 wxPyEndAllowThreads(__tstate);
27530 if (PyErr_Occurred()) SWIG_fail;
27531 }
27532 resultobj = result;
27533 return resultobj;
27534 fail:
27535 return NULL;
27536 }
27537
27538
27539 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27540 PyObject *resultobj;
27541 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27542 PyObject *arg2 = (PyObject *) 0 ;
27543 bool result;
27544 PyObject * obj0 = 0 ;
27545 PyObject * obj1 = 0 ;
27546 char *kwnames[] = {
27547 (char *) "self",(char *) "data", NULL
27548 };
27549
27550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27552 if (SWIG_arg_fail(1)) SWIG_fail;
27553 arg2 = obj1;
27554 {
27555 PyThreadState* __tstate = wxPyBeginAllowThreads();
27556 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27557
27558 wxPyEndAllowThreads(__tstate);
27559 if (PyErr_Occurred()) SWIG_fail;
27560 }
27561 {
27562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27563 }
27564 return resultobj;
27565 fail:
27566 return NULL;
27567 }
27568
27569
27570 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27571 PyObject *obj;
27572 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27573 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27574 Py_INCREF(obj);
27575 return Py_BuildValue((char *)"");
27576 }
27577 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27578 PyObject *resultobj;
27579 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27580 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27581 wxPyDataObjectSimple *result;
27582 PyObject * obj0 = 0 ;
27583 char *kwnames[] = {
27584 (char *) "format", NULL
27585 };
27586
27587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27588 if (obj0) {
27589 {
27590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27591 if (SWIG_arg_fail(1)) SWIG_fail;
27592 if (arg1 == NULL) {
27593 SWIG_null_ref("wxDataFormat");
27594 }
27595 if (SWIG_arg_fail(1)) SWIG_fail;
27596 }
27597 }
27598 {
27599 PyThreadState* __tstate = wxPyBeginAllowThreads();
27600 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27601
27602 wxPyEndAllowThreads(__tstate);
27603 if (PyErr_Occurred()) SWIG_fail;
27604 }
27605 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27606 return resultobj;
27607 fail:
27608 return NULL;
27609 }
27610
27611
27612 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27613 PyObject *resultobj;
27614 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27615 PyObject *arg2 = (PyObject *) 0 ;
27616 PyObject *arg3 = (PyObject *) 0 ;
27617 PyObject * obj0 = 0 ;
27618 PyObject * obj1 = 0 ;
27619 PyObject * obj2 = 0 ;
27620 char *kwnames[] = {
27621 (char *) "self",(char *) "self",(char *) "_class", NULL
27622 };
27623
27624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27626 if (SWIG_arg_fail(1)) SWIG_fail;
27627 arg2 = obj1;
27628 arg3 = obj2;
27629 {
27630 PyThreadState* __tstate = wxPyBeginAllowThreads();
27631 (arg1)->_setCallbackInfo(arg2,arg3);
27632
27633 wxPyEndAllowThreads(__tstate);
27634 if (PyErr_Occurred()) SWIG_fail;
27635 }
27636 Py_INCREF(Py_None); resultobj = Py_None;
27637 return resultobj;
27638 fail:
27639 return NULL;
27640 }
27641
27642
27643 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27644 PyObject *obj;
27645 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27646 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27647 Py_INCREF(obj);
27648 return Py_BuildValue((char *)"");
27649 }
27650 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27651 PyObject *resultobj;
27652 wxDataObjectComposite *result;
27653 char *kwnames[] = {
27654 NULL
27655 };
27656
27657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27658 {
27659 PyThreadState* __tstate = wxPyBeginAllowThreads();
27660 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27661
27662 wxPyEndAllowThreads(__tstate);
27663 if (PyErr_Occurred()) SWIG_fail;
27664 }
27665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27666 return resultobj;
27667 fail:
27668 return NULL;
27669 }
27670
27671
27672 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27673 PyObject *resultobj;
27674 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27675 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27676 bool arg3 = (bool) false ;
27677 PyObject * obj0 = 0 ;
27678 PyObject * obj1 = 0 ;
27679 PyObject * obj2 = 0 ;
27680 char *kwnames[] = {
27681 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27682 };
27683
27684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27686 if (SWIG_arg_fail(1)) SWIG_fail;
27687 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27688 if (SWIG_arg_fail(2)) SWIG_fail;
27689 if (obj2) {
27690 {
27691 arg3 = (bool)(SWIG_As_bool(obj2));
27692 if (SWIG_arg_fail(3)) SWIG_fail;
27693 }
27694 }
27695 {
27696 PyThreadState* __tstate = wxPyBeginAllowThreads();
27697 (arg1)->Add(arg2,arg3);
27698
27699 wxPyEndAllowThreads(__tstate);
27700 if (PyErr_Occurred()) SWIG_fail;
27701 }
27702 Py_INCREF(Py_None); resultobj = Py_None;
27703 return resultobj;
27704 fail:
27705 return NULL;
27706 }
27707
27708
27709 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27710 PyObject *obj;
27711 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27712 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27713 Py_INCREF(obj);
27714 return Py_BuildValue((char *)"");
27715 }
27716 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27717 PyObject *resultobj;
27718 wxString const &arg1_defvalue = wxPyEmptyString ;
27719 wxString *arg1 = (wxString *) &arg1_defvalue ;
27720 wxTextDataObject *result;
27721 bool temp1 = false ;
27722 PyObject * obj0 = 0 ;
27723 char *kwnames[] = {
27724 (char *) "text", NULL
27725 };
27726
27727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27728 if (obj0) {
27729 {
27730 arg1 = wxString_in_helper(obj0);
27731 if (arg1 == NULL) SWIG_fail;
27732 temp1 = true;
27733 }
27734 }
27735 {
27736 PyThreadState* __tstate = wxPyBeginAllowThreads();
27737 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27738
27739 wxPyEndAllowThreads(__tstate);
27740 if (PyErr_Occurred()) SWIG_fail;
27741 }
27742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27743 {
27744 if (temp1)
27745 delete arg1;
27746 }
27747 return resultobj;
27748 fail:
27749 {
27750 if (temp1)
27751 delete arg1;
27752 }
27753 return NULL;
27754 }
27755
27756
27757 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27758 PyObject *resultobj;
27759 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27760 size_t result;
27761 PyObject * obj0 = 0 ;
27762 char *kwnames[] = {
27763 (char *) "self", NULL
27764 };
27765
27766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27768 if (SWIG_arg_fail(1)) SWIG_fail;
27769 {
27770 PyThreadState* __tstate = wxPyBeginAllowThreads();
27771 result = (size_t)(arg1)->GetTextLength();
27772
27773 wxPyEndAllowThreads(__tstate);
27774 if (PyErr_Occurred()) SWIG_fail;
27775 }
27776 {
27777 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27778 }
27779 return resultobj;
27780 fail:
27781 return NULL;
27782 }
27783
27784
27785 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27786 PyObject *resultobj;
27787 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27788 wxString result;
27789 PyObject * obj0 = 0 ;
27790 char *kwnames[] = {
27791 (char *) "self", NULL
27792 };
27793
27794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27796 if (SWIG_arg_fail(1)) SWIG_fail;
27797 {
27798 PyThreadState* __tstate = wxPyBeginAllowThreads();
27799 result = (arg1)->GetText();
27800
27801 wxPyEndAllowThreads(__tstate);
27802 if (PyErr_Occurred()) SWIG_fail;
27803 }
27804 {
27805 #if wxUSE_UNICODE
27806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27807 #else
27808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27809 #endif
27810 }
27811 return resultobj;
27812 fail:
27813 return NULL;
27814 }
27815
27816
27817 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27818 PyObject *resultobj;
27819 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27820 wxString *arg2 = 0 ;
27821 bool temp2 = false ;
27822 PyObject * obj0 = 0 ;
27823 PyObject * obj1 = 0 ;
27824 char *kwnames[] = {
27825 (char *) "self",(char *) "text", NULL
27826 };
27827
27828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27830 if (SWIG_arg_fail(1)) SWIG_fail;
27831 {
27832 arg2 = wxString_in_helper(obj1);
27833 if (arg2 == NULL) SWIG_fail;
27834 temp2 = true;
27835 }
27836 {
27837 PyThreadState* __tstate = wxPyBeginAllowThreads();
27838 (arg1)->SetText((wxString const &)*arg2);
27839
27840 wxPyEndAllowThreads(__tstate);
27841 if (PyErr_Occurred()) SWIG_fail;
27842 }
27843 Py_INCREF(Py_None); resultobj = Py_None;
27844 {
27845 if (temp2)
27846 delete arg2;
27847 }
27848 return resultobj;
27849 fail:
27850 {
27851 if (temp2)
27852 delete arg2;
27853 }
27854 return NULL;
27855 }
27856
27857
27858 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27859 PyObject *obj;
27860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27861 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27862 Py_INCREF(obj);
27863 return Py_BuildValue((char *)"");
27864 }
27865 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27866 PyObject *resultobj;
27867 wxString const &arg1_defvalue = wxPyEmptyString ;
27868 wxString *arg1 = (wxString *) &arg1_defvalue ;
27869 wxPyTextDataObject *result;
27870 bool temp1 = false ;
27871 PyObject * obj0 = 0 ;
27872 char *kwnames[] = {
27873 (char *) "text", NULL
27874 };
27875
27876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27877 if (obj0) {
27878 {
27879 arg1 = wxString_in_helper(obj0);
27880 if (arg1 == NULL) SWIG_fail;
27881 temp1 = true;
27882 }
27883 }
27884 {
27885 PyThreadState* __tstate = wxPyBeginAllowThreads();
27886 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27887
27888 wxPyEndAllowThreads(__tstate);
27889 if (PyErr_Occurred()) SWIG_fail;
27890 }
27891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27892 {
27893 if (temp1)
27894 delete arg1;
27895 }
27896 return resultobj;
27897 fail:
27898 {
27899 if (temp1)
27900 delete arg1;
27901 }
27902 return NULL;
27903 }
27904
27905
27906 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27907 PyObject *resultobj;
27908 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27909 PyObject *arg2 = (PyObject *) 0 ;
27910 PyObject *arg3 = (PyObject *) 0 ;
27911 PyObject * obj0 = 0 ;
27912 PyObject * obj1 = 0 ;
27913 PyObject * obj2 = 0 ;
27914 char *kwnames[] = {
27915 (char *) "self",(char *) "self",(char *) "_class", NULL
27916 };
27917
27918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27920 if (SWIG_arg_fail(1)) SWIG_fail;
27921 arg2 = obj1;
27922 arg3 = obj2;
27923 {
27924 PyThreadState* __tstate = wxPyBeginAllowThreads();
27925 (arg1)->_setCallbackInfo(arg2,arg3);
27926
27927 wxPyEndAllowThreads(__tstate);
27928 if (PyErr_Occurred()) SWIG_fail;
27929 }
27930 Py_INCREF(Py_None); resultobj = Py_None;
27931 return resultobj;
27932 fail:
27933 return NULL;
27934 }
27935
27936
27937 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27938 PyObject *obj;
27939 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27940 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27941 Py_INCREF(obj);
27942 return Py_BuildValue((char *)"");
27943 }
27944 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27945 PyObject *resultobj;
27946 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27947 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27948 wxBitmapDataObject *result;
27949 PyObject * obj0 = 0 ;
27950 char *kwnames[] = {
27951 (char *) "bitmap", NULL
27952 };
27953
27954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27955 if (obj0) {
27956 {
27957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27958 if (SWIG_arg_fail(1)) SWIG_fail;
27959 if (arg1 == NULL) {
27960 SWIG_null_ref("wxBitmap");
27961 }
27962 if (SWIG_arg_fail(1)) SWIG_fail;
27963 }
27964 }
27965 {
27966 PyThreadState* __tstate = wxPyBeginAllowThreads();
27967 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27968
27969 wxPyEndAllowThreads(__tstate);
27970 if (PyErr_Occurred()) SWIG_fail;
27971 }
27972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27973 return resultobj;
27974 fail:
27975 return NULL;
27976 }
27977
27978
27979 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27980 PyObject *resultobj;
27981 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27982 wxBitmap result;
27983 PyObject * obj0 = 0 ;
27984 char *kwnames[] = {
27985 (char *) "self", NULL
27986 };
27987
27988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27990 if (SWIG_arg_fail(1)) SWIG_fail;
27991 {
27992 PyThreadState* __tstate = wxPyBeginAllowThreads();
27993 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27994
27995 wxPyEndAllowThreads(__tstate);
27996 if (PyErr_Occurred()) SWIG_fail;
27997 }
27998 {
27999 wxBitmap * resultptr;
28000 resultptr = new wxBitmap((wxBitmap &)(result));
28001 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
28002 }
28003 return resultobj;
28004 fail:
28005 return NULL;
28006 }
28007
28008
28009 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
28010 PyObject *resultobj;
28011 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
28012 wxBitmap *arg2 = 0 ;
28013 PyObject * obj0 = 0 ;
28014 PyObject * obj1 = 0 ;
28015 char *kwnames[] = {
28016 (char *) "self",(char *) "bitmap", NULL
28017 };
28018
28019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
28020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28021 if (SWIG_arg_fail(1)) SWIG_fail;
28022 {
28023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28024 if (SWIG_arg_fail(2)) SWIG_fail;
28025 if (arg2 == NULL) {
28026 SWIG_null_ref("wxBitmap");
28027 }
28028 if (SWIG_arg_fail(2)) SWIG_fail;
28029 }
28030 {
28031 PyThreadState* __tstate = wxPyBeginAllowThreads();
28032 (arg1)->SetBitmap((wxBitmap const &)*arg2);
28033
28034 wxPyEndAllowThreads(__tstate);
28035 if (PyErr_Occurred()) SWIG_fail;
28036 }
28037 Py_INCREF(Py_None); resultobj = Py_None;
28038 return resultobj;
28039 fail:
28040 return NULL;
28041 }
28042
28043
28044 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
28045 PyObject *obj;
28046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28047 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
28048 Py_INCREF(obj);
28049 return Py_BuildValue((char *)"");
28050 }
28051 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28052 PyObject *resultobj;
28053 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28054 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28055 wxPyBitmapDataObject *result;
28056 PyObject * obj0 = 0 ;
28057 char *kwnames[] = {
28058 (char *) "bitmap", NULL
28059 };
28060
28061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28062 if (obj0) {
28063 {
28064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28065 if (SWIG_arg_fail(1)) SWIG_fail;
28066 if (arg1 == NULL) {
28067 SWIG_null_ref("wxBitmap");
28068 }
28069 if (SWIG_arg_fail(1)) SWIG_fail;
28070 }
28071 }
28072 {
28073 PyThreadState* __tstate = wxPyBeginAllowThreads();
28074 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28075
28076 wxPyEndAllowThreads(__tstate);
28077 if (PyErr_Occurred()) SWIG_fail;
28078 }
28079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28080 return resultobj;
28081 fail:
28082 return NULL;
28083 }
28084
28085
28086 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28087 PyObject *resultobj;
28088 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28089 PyObject *arg2 = (PyObject *) 0 ;
28090 PyObject *arg3 = (PyObject *) 0 ;
28091 PyObject * obj0 = 0 ;
28092 PyObject * obj1 = 0 ;
28093 PyObject * obj2 = 0 ;
28094 char *kwnames[] = {
28095 (char *) "self",(char *) "self",(char *) "_class", NULL
28096 };
28097
28098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28100 if (SWIG_arg_fail(1)) SWIG_fail;
28101 arg2 = obj1;
28102 arg3 = obj2;
28103 {
28104 PyThreadState* __tstate = wxPyBeginAllowThreads();
28105 (arg1)->_setCallbackInfo(arg2,arg3);
28106
28107 wxPyEndAllowThreads(__tstate);
28108 if (PyErr_Occurred()) SWIG_fail;
28109 }
28110 Py_INCREF(Py_None); resultobj = Py_None;
28111 return resultobj;
28112 fail:
28113 return NULL;
28114 }
28115
28116
28117 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28118 PyObject *obj;
28119 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28120 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28121 Py_INCREF(obj);
28122 return Py_BuildValue((char *)"");
28123 }
28124 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28125 PyObject *resultobj;
28126 wxFileDataObject *result;
28127 char *kwnames[] = {
28128 NULL
28129 };
28130
28131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28132 {
28133 PyThreadState* __tstate = wxPyBeginAllowThreads();
28134 result = (wxFileDataObject *)new wxFileDataObject();
28135
28136 wxPyEndAllowThreads(__tstate);
28137 if (PyErr_Occurred()) SWIG_fail;
28138 }
28139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28140 return resultobj;
28141 fail:
28142 return NULL;
28143 }
28144
28145
28146 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28147 PyObject *resultobj;
28148 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28149 wxArrayString *result;
28150 PyObject * obj0 = 0 ;
28151 char *kwnames[] = {
28152 (char *) "self", NULL
28153 };
28154
28155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28157 if (SWIG_arg_fail(1)) SWIG_fail;
28158 {
28159 PyThreadState* __tstate = wxPyBeginAllowThreads();
28160 {
28161 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28162 result = (wxArrayString *) &_result_ref;
28163 }
28164
28165 wxPyEndAllowThreads(__tstate);
28166 if (PyErr_Occurred()) SWIG_fail;
28167 }
28168 {
28169 resultobj = wxArrayString2PyList_helper(*result);
28170 }
28171 return resultobj;
28172 fail:
28173 return NULL;
28174 }
28175
28176
28177 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28178 PyObject *resultobj;
28179 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28180 wxString *arg2 = 0 ;
28181 bool temp2 = false ;
28182 PyObject * obj0 = 0 ;
28183 PyObject * obj1 = 0 ;
28184 char *kwnames[] = {
28185 (char *) "self",(char *) "filename", NULL
28186 };
28187
28188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28190 if (SWIG_arg_fail(1)) SWIG_fail;
28191 {
28192 arg2 = wxString_in_helper(obj1);
28193 if (arg2 == NULL) SWIG_fail;
28194 temp2 = true;
28195 }
28196 {
28197 PyThreadState* __tstate = wxPyBeginAllowThreads();
28198 (arg1)->AddFile((wxString const &)*arg2);
28199
28200 wxPyEndAllowThreads(__tstate);
28201 if (PyErr_Occurred()) SWIG_fail;
28202 }
28203 Py_INCREF(Py_None); resultobj = Py_None;
28204 {
28205 if (temp2)
28206 delete arg2;
28207 }
28208 return resultobj;
28209 fail:
28210 {
28211 if (temp2)
28212 delete arg2;
28213 }
28214 return NULL;
28215 }
28216
28217
28218 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28219 PyObject *obj;
28220 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28221 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28222 Py_INCREF(obj);
28223 return Py_BuildValue((char *)"");
28224 }
28225 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28226 PyObject *resultobj;
28227 wxDataFormat *arg1 = 0 ;
28228 wxCustomDataObject *result;
28229 PyObject * obj0 = 0 ;
28230
28231 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28232 {
28233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28234 if (SWIG_arg_fail(1)) SWIG_fail;
28235 if (arg1 == NULL) {
28236 SWIG_null_ref("wxDataFormat");
28237 }
28238 if (SWIG_arg_fail(1)) SWIG_fail;
28239 }
28240 {
28241 PyThreadState* __tstate = wxPyBeginAllowThreads();
28242 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28243
28244 wxPyEndAllowThreads(__tstate);
28245 if (PyErr_Occurred()) SWIG_fail;
28246 }
28247 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28248 return resultobj;
28249 fail:
28250 return NULL;
28251 }
28252
28253
28254 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28255 PyObject *resultobj;
28256 wxString *arg1 = 0 ;
28257 wxCustomDataObject *result;
28258 bool temp1 = false ;
28259 PyObject * obj0 = 0 ;
28260
28261 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28262 {
28263 arg1 = wxString_in_helper(obj0);
28264 if (arg1 == NULL) SWIG_fail;
28265 temp1 = true;
28266 }
28267 {
28268 PyThreadState* __tstate = wxPyBeginAllowThreads();
28269 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28270
28271 wxPyEndAllowThreads(__tstate);
28272 if (PyErr_Occurred()) SWIG_fail;
28273 }
28274 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28275 {
28276 if (temp1)
28277 delete arg1;
28278 }
28279 return resultobj;
28280 fail:
28281 {
28282 if (temp1)
28283 delete arg1;
28284 }
28285 return NULL;
28286 }
28287
28288
28289 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28290 PyObject *resultobj;
28291 wxCustomDataObject *result;
28292
28293 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 result = (wxCustomDataObject *)new wxCustomDataObject();
28297
28298 wxPyEndAllowThreads(__tstate);
28299 if (PyErr_Occurred()) SWIG_fail;
28300 }
28301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28302 return resultobj;
28303 fail:
28304 return NULL;
28305 }
28306
28307
28308 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28309 int argc;
28310 PyObject *argv[2];
28311 int ii;
28312
28313 argc = PyObject_Length(args);
28314 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28315 argv[ii] = PyTuple_GetItem(args,ii);
28316 }
28317 if (argc == 0) {
28318 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28319 }
28320 if (argc == 1) {
28321 int _v;
28322 {
28323 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28324 }
28325 if (_v) {
28326 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28327 }
28328 }
28329 if (argc == 1) {
28330 int _v;
28331 {
28332 void *ptr = 0;
28333 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28334 _v = 0;
28335 PyErr_Clear();
28336 } else {
28337 _v = (ptr != 0);
28338 }
28339 }
28340 if (_v) {
28341 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28342 }
28343 }
28344
28345 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28346 return NULL;
28347 }
28348
28349
28350 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28351 PyObject *resultobj;
28352 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28353 PyObject *arg2 = (PyObject *) 0 ;
28354 bool result;
28355 PyObject * obj0 = 0 ;
28356 PyObject * obj1 = 0 ;
28357 char *kwnames[] = {
28358 (char *) "self",(char *) "data", NULL
28359 };
28360
28361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28363 if (SWIG_arg_fail(1)) SWIG_fail;
28364 arg2 = obj1;
28365 {
28366 PyThreadState* __tstate = wxPyBeginAllowThreads();
28367 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28368
28369 wxPyEndAllowThreads(__tstate);
28370 if (PyErr_Occurred()) SWIG_fail;
28371 }
28372 {
28373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28374 }
28375 return resultobj;
28376 fail:
28377 return NULL;
28378 }
28379
28380
28381 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28382 PyObject *resultobj;
28383 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28384 size_t result;
28385 PyObject * obj0 = 0 ;
28386 char *kwnames[] = {
28387 (char *) "self", NULL
28388 };
28389
28390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28392 if (SWIG_arg_fail(1)) SWIG_fail;
28393 {
28394 PyThreadState* __tstate = wxPyBeginAllowThreads();
28395 result = (size_t)(arg1)->GetSize();
28396
28397 wxPyEndAllowThreads(__tstate);
28398 if (PyErr_Occurred()) SWIG_fail;
28399 }
28400 {
28401 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28402 }
28403 return resultobj;
28404 fail:
28405 return NULL;
28406 }
28407
28408
28409 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28410 PyObject *resultobj;
28411 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28412 PyObject *result;
28413 PyObject * obj0 = 0 ;
28414 char *kwnames[] = {
28415 (char *) "self", NULL
28416 };
28417
28418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28420 if (SWIG_arg_fail(1)) SWIG_fail;
28421 {
28422 PyThreadState* __tstate = wxPyBeginAllowThreads();
28423 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28424
28425 wxPyEndAllowThreads(__tstate);
28426 if (PyErr_Occurred()) SWIG_fail;
28427 }
28428 resultobj = result;
28429 return resultobj;
28430 fail:
28431 return NULL;
28432 }
28433
28434
28435 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28436 PyObject *obj;
28437 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28438 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28439 Py_INCREF(obj);
28440 return Py_BuildValue((char *)"");
28441 }
28442 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28443 PyObject *resultobj;
28444 wxURLDataObject *result;
28445 char *kwnames[] = {
28446 NULL
28447 };
28448
28449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28450 {
28451 PyThreadState* __tstate = wxPyBeginAllowThreads();
28452 result = (wxURLDataObject *)new wxURLDataObject();
28453
28454 wxPyEndAllowThreads(__tstate);
28455 if (PyErr_Occurred()) SWIG_fail;
28456 }
28457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28458 return resultobj;
28459 fail:
28460 return NULL;
28461 }
28462
28463
28464 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28465 PyObject *resultobj;
28466 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28467 wxString result;
28468 PyObject * obj0 = 0 ;
28469 char *kwnames[] = {
28470 (char *) "self", NULL
28471 };
28472
28473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28475 if (SWIG_arg_fail(1)) SWIG_fail;
28476 {
28477 PyThreadState* __tstate = wxPyBeginAllowThreads();
28478 result = (arg1)->GetURL();
28479
28480 wxPyEndAllowThreads(__tstate);
28481 if (PyErr_Occurred()) SWIG_fail;
28482 }
28483 {
28484 #if wxUSE_UNICODE
28485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28486 #else
28487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28488 #endif
28489 }
28490 return resultobj;
28491 fail:
28492 return NULL;
28493 }
28494
28495
28496 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28497 PyObject *resultobj;
28498 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28499 wxString *arg2 = 0 ;
28500 bool temp2 = false ;
28501 PyObject * obj0 = 0 ;
28502 PyObject * obj1 = 0 ;
28503 char *kwnames[] = {
28504 (char *) "self",(char *) "url", NULL
28505 };
28506
28507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28509 if (SWIG_arg_fail(1)) SWIG_fail;
28510 {
28511 arg2 = wxString_in_helper(obj1);
28512 if (arg2 == NULL) SWIG_fail;
28513 temp2 = true;
28514 }
28515 {
28516 PyThreadState* __tstate = wxPyBeginAllowThreads();
28517 (arg1)->SetURL((wxString const &)*arg2);
28518
28519 wxPyEndAllowThreads(__tstate);
28520 if (PyErr_Occurred()) SWIG_fail;
28521 }
28522 Py_INCREF(Py_None); resultobj = Py_None;
28523 {
28524 if (temp2)
28525 delete arg2;
28526 }
28527 return resultobj;
28528 fail:
28529 {
28530 if (temp2)
28531 delete arg2;
28532 }
28533 return NULL;
28534 }
28535
28536
28537 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28538 PyObject *obj;
28539 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28540 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28541 Py_INCREF(obj);
28542 return Py_BuildValue((char *)"");
28543 }
28544 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28545 PyObject *resultobj;
28546 wxMetafileDataObject *result;
28547 char *kwnames[] = {
28548 NULL
28549 };
28550
28551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28552 {
28553 PyThreadState* __tstate = wxPyBeginAllowThreads();
28554 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28555
28556 wxPyEndAllowThreads(__tstate);
28557 if (PyErr_Occurred()) SWIG_fail;
28558 }
28559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28560 return resultobj;
28561 fail:
28562 return NULL;
28563 }
28564
28565
28566 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28567 PyObject *resultobj;
28568 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28569 wxMetafile *arg2 = 0 ;
28570 PyObject * obj0 = 0 ;
28571 PyObject * obj1 = 0 ;
28572 char *kwnames[] = {
28573 (char *) "self",(char *) "metafile", NULL
28574 };
28575
28576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28578 if (SWIG_arg_fail(1)) SWIG_fail;
28579 {
28580 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28581 if (SWIG_arg_fail(2)) SWIG_fail;
28582 if (arg2 == NULL) {
28583 SWIG_null_ref("wxMetafile");
28584 }
28585 if (SWIG_arg_fail(2)) SWIG_fail;
28586 }
28587 {
28588 PyThreadState* __tstate = wxPyBeginAllowThreads();
28589 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28590
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 Py_INCREF(Py_None); resultobj = Py_None;
28595 return resultobj;
28596 fail:
28597 return NULL;
28598 }
28599
28600
28601 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28602 PyObject *resultobj;
28603 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28604 wxMetafile result;
28605 PyObject * obj0 = 0 ;
28606 char *kwnames[] = {
28607 (char *) "self", NULL
28608 };
28609
28610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28612 if (SWIG_arg_fail(1)) SWIG_fail;
28613 {
28614 PyThreadState* __tstate = wxPyBeginAllowThreads();
28615 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28616
28617 wxPyEndAllowThreads(__tstate);
28618 if (PyErr_Occurred()) SWIG_fail;
28619 }
28620 {
28621 wxMetafile * resultptr;
28622 resultptr = new wxMetafile((wxMetafile &)(result));
28623 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28624 }
28625 return resultobj;
28626 fail:
28627 return NULL;
28628 }
28629
28630
28631 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28632 PyObject *obj;
28633 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28634 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28635 Py_INCREF(obj);
28636 return Py_BuildValue((char *)"");
28637 }
28638 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28639 PyObject *resultobj;
28640 wxDragResult arg1 ;
28641 bool result;
28642 PyObject * obj0 = 0 ;
28643 char *kwnames[] = {
28644 (char *) "res", NULL
28645 };
28646
28647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28648 {
28649 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28650 if (SWIG_arg_fail(1)) SWIG_fail;
28651 }
28652 {
28653 PyThreadState* __tstate = wxPyBeginAllowThreads();
28654 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28655
28656 wxPyEndAllowThreads(__tstate);
28657 if (PyErr_Occurred()) SWIG_fail;
28658 }
28659 {
28660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28661 }
28662 return resultobj;
28663 fail:
28664 return NULL;
28665 }
28666
28667
28668 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28669 PyObject *resultobj;
28670 wxWindow *arg1 = (wxWindow *) 0 ;
28671 wxCursor const &arg2_defvalue = wxNullCursor ;
28672 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28673 wxCursor const &arg3_defvalue = wxNullCursor ;
28674 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28675 wxCursor const &arg4_defvalue = wxNullCursor ;
28676 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28677 wxPyDropSource *result;
28678 PyObject * obj0 = 0 ;
28679 PyObject * obj1 = 0 ;
28680 PyObject * obj2 = 0 ;
28681 PyObject * obj3 = 0 ;
28682 char *kwnames[] = {
28683 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28684 };
28685
28686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28688 if (SWIG_arg_fail(1)) SWIG_fail;
28689 if (obj1) {
28690 {
28691 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28692 if (SWIG_arg_fail(2)) SWIG_fail;
28693 if (arg2 == NULL) {
28694 SWIG_null_ref("wxCursor");
28695 }
28696 if (SWIG_arg_fail(2)) SWIG_fail;
28697 }
28698 }
28699 if (obj2) {
28700 {
28701 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28702 if (SWIG_arg_fail(3)) SWIG_fail;
28703 if (arg3 == NULL) {
28704 SWIG_null_ref("wxCursor");
28705 }
28706 if (SWIG_arg_fail(3)) SWIG_fail;
28707 }
28708 }
28709 if (obj3) {
28710 {
28711 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28712 if (SWIG_arg_fail(4)) SWIG_fail;
28713 if (arg4 == NULL) {
28714 SWIG_null_ref("wxCursor");
28715 }
28716 if (SWIG_arg_fail(4)) SWIG_fail;
28717 }
28718 }
28719 {
28720 PyThreadState* __tstate = wxPyBeginAllowThreads();
28721 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28722
28723 wxPyEndAllowThreads(__tstate);
28724 if (PyErr_Occurred()) SWIG_fail;
28725 }
28726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28727 return resultobj;
28728 fail:
28729 return NULL;
28730 }
28731
28732
28733 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28734 PyObject *resultobj;
28735 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28736 PyObject *arg2 = (PyObject *) 0 ;
28737 PyObject *arg3 = (PyObject *) 0 ;
28738 int arg4 ;
28739 PyObject * obj0 = 0 ;
28740 PyObject * obj1 = 0 ;
28741 PyObject * obj2 = 0 ;
28742 PyObject * obj3 = 0 ;
28743 char *kwnames[] = {
28744 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28745 };
28746
28747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28749 if (SWIG_arg_fail(1)) SWIG_fail;
28750 arg2 = obj1;
28751 arg3 = obj2;
28752 {
28753 arg4 = (int)(SWIG_As_int(obj3));
28754 if (SWIG_arg_fail(4)) SWIG_fail;
28755 }
28756 {
28757 PyThreadState* __tstate = wxPyBeginAllowThreads();
28758 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28759
28760 wxPyEndAllowThreads(__tstate);
28761 if (PyErr_Occurred()) SWIG_fail;
28762 }
28763 Py_INCREF(Py_None); resultobj = Py_None;
28764 return resultobj;
28765 fail:
28766 return NULL;
28767 }
28768
28769
28770 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28771 PyObject *resultobj;
28772 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28773 PyObject * obj0 = 0 ;
28774 char *kwnames[] = {
28775 (char *) "self", NULL
28776 };
28777
28778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28780 if (SWIG_arg_fail(1)) SWIG_fail;
28781 {
28782 PyThreadState* __tstate = wxPyBeginAllowThreads();
28783 delete arg1;
28784
28785 wxPyEndAllowThreads(__tstate);
28786 if (PyErr_Occurred()) SWIG_fail;
28787 }
28788 Py_INCREF(Py_None); resultobj = Py_None;
28789 return resultobj;
28790 fail:
28791 return NULL;
28792 }
28793
28794
28795 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28796 PyObject *resultobj;
28797 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28798 wxDataObject *arg2 = 0 ;
28799 PyObject * obj0 = 0 ;
28800 PyObject * obj1 = 0 ;
28801 char *kwnames[] = {
28802 (char *) "self",(char *) "data", NULL
28803 };
28804
28805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28807 if (SWIG_arg_fail(1)) SWIG_fail;
28808 {
28809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28810 if (SWIG_arg_fail(2)) SWIG_fail;
28811 if (arg2 == NULL) {
28812 SWIG_null_ref("wxDataObject");
28813 }
28814 if (SWIG_arg_fail(2)) SWIG_fail;
28815 }
28816 {
28817 PyThreadState* __tstate = wxPyBeginAllowThreads();
28818 (arg1)->SetData(*arg2);
28819
28820 wxPyEndAllowThreads(__tstate);
28821 if (PyErr_Occurred()) SWIG_fail;
28822 }
28823 Py_INCREF(Py_None); resultobj = Py_None;
28824 return resultobj;
28825 fail:
28826 return NULL;
28827 }
28828
28829
28830 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28831 PyObject *resultobj;
28832 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28833 wxDataObject *result;
28834 PyObject * obj0 = 0 ;
28835 char *kwnames[] = {
28836 (char *) "self", NULL
28837 };
28838
28839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28841 if (SWIG_arg_fail(1)) SWIG_fail;
28842 {
28843 PyThreadState* __tstate = wxPyBeginAllowThreads();
28844 result = (wxDataObject *)(arg1)->GetDataObject();
28845
28846 wxPyEndAllowThreads(__tstate);
28847 if (PyErr_Occurred()) SWIG_fail;
28848 }
28849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28850 return resultobj;
28851 fail:
28852 return NULL;
28853 }
28854
28855
28856 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28857 PyObject *resultobj;
28858 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28859 wxDragResult arg2 ;
28860 wxCursor *arg3 = 0 ;
28861 PyObject * obj0 = 0 ;
28862 PyObject * obj1 = 0 ;
28863 PyObject * obj2 = 0 ;
28864 char *kwnames[] = {
28865 (char *) "self",(char *) "res",(char *) "cursor", NULL
28866 };
28867
28868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28870 if (SWIG_arg_fail(1)) SWIG_fail;
28871 {
28872 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28873 if (SWIG_arg_fail(2)) SWIG_fail;
28874 }
28875 {
28876 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28877 if (SWIG_arg_fail(3)) SWIG_fail;
28878 if (arg3 == NULL) {
28879 SWIG_null_ref("wxCursor");
28880 }
28881 if (SWIG_arg_fail(3)) SWIG_fail;
28882 }
28883 {
28884 PyThreadState* __tstate = wxPyBeginAllowThreads();
28885 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28886
28887 wxPyEndAllowThreads(__tstate);
28888 if (PyErr_Occurred()) SWIG_fail;
28889 }
28890 Py_INCREF(Py_None); resultobj = Py_None;
28891 return resultobj;
28892 fail:
28893 return NULL;
28894 }
28895
28896
28897 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28898 PyObject *resultobj;
28899 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28900 int arg2 = (int) wxDrag_CopyOnly ;
28901 wxDragResult result;
28902 PyObject * obj0 = 0 ;
28903 PyObject * obj1 = 0 ;
28904 char *kwnames[] = {
28905 (char *) "self",(char *) "flags", NULL
28906 };
28907
28908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28910 if (SWIG_arg_fail(1)) SWIG_fail;
28911 if (obj1) {
28912 {
28913 arg2 = (int)(SWIG_As_int(obj1));
28914 if (SWIG_arg_fail(2)) SWIG_fail;
28915 }
28916 }
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28920
28921 wxPyEndAllowThreads(__tstate);
28922 if (PyErr_Occurred()) SWIG_fail;
28923 }
28924 resultobj = SWIG_From_int((result));
28925 return resultobj;
28926 fail:
28927 return NULL;
28928 }
28929
28930
28931 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28932 PyObject *resultobj;
28933 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28934 wxDragResult arg2 ;
28935 bool result;
28936 PyObject * obj0 = 0 ;
28937 PyObject * obj1 = 0 ;
28938 char *kwnames[] = {
28939 (char *) "self",(char *) "effect", NULL
28940 };
28941
28942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28944 if (SWIG_arg_fail(1)) SWIG_fail;
28945 {
28946 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28947 if (SWIG_arg_fail(2)) SWIG_fail;
28948 }
28949 {
28950 PyThreadState* __tstate = wxPyBeginAllowThreads();
28951 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28952
28953 wxPyEndAllowThreads(__tstate);
28954 if (PyErr_Occurred()) SWIG_fail;
28955 }
28956 {
28957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28958 }
28959 return resultobj;
28960 fail:
28961 return NULL;
28962 }
28963
28964
28965 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28966 PyObject *obj;
28967 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28968 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28969 Py_INCREF(obj);
28970 return Py_BuildValue((char *)"");
28971 }
28972 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28973 PyObject *resultobj;
28974 wxDataObject *arg1 = (wxDataObject *) NULL ;
28975 wxPyDropTarget *result;
28976 PyObject * obj0 = 0 ;
28977 char *kwnames[] = {
28978 (char *) "dataObject", NULL
28979 };
28980
28981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28982 if (obj0) {
28983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28984 if (SWIG_arg_fail(1)) SWIG_fail;
28985 }
28986 {
28987 PyThreadState* __tstate = wxPyBeginAllowThreads();
28988 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28989
28990 wxPyEndAllowThreads(__tstate);
28991 if (PyErr_Occurred()) SWIG_fail;
28992 }
28993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28994 return resultobj;
28995 fail:
28996 return NULL;
28997 }
28998
28999
29000 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29001 PyObject *resultobj;
29002 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29003 PyObject *arg2 = (PyObject *) 0 ;
29004 PyObject *arg3 = (PyObject *) 0 ;
29005 PyObject * obj0 = 0 ;
29006 PyObject * obj1 = 0 ;
29007 PyObject * obj2 = 0 ;
29008 char *kwnames[] = {
29009 (char *) "self",(char *) "self",(char *) "_class", NULL
29010 };
29011
29012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29014 if (SWIG_arg_fail(1)) SWIG_fail;
29015 arg2 = obj1;
29016 arg3 = obj2;
29017 {
29018 PyThreadState* __tstate = wxPyBeginAllowThreads();
29019 (arg1)->_setCallbackInfo(arg2,arg3);
29020
29021 wxPyEndAllowThreads(__tstate);
29022 if (PyErr_Occurred()) SWIG_fail;
29023 }
29024 Py_INCREF(Py_None); resultobj = Py_None;
29025 return resultobj;
29026 fail:
29027 return NULL;
29028 }
29029
29030
29031 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29032 PyObject *resultobj;
29033 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29034 PyObject * obj0 = 0 ;
29035 char *kwnames[] = {
29036 (char *) "self", NULL
29037 };
29038
29039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
29040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29041 if (SWIG_arg_fail(1)) SWIG_fail;
29042 {
29043 PyThreadState* __tstate = wxPyBeginAllowThreads();
29044 delete arg1;
29045
29046 wxPyEndAllowThreads(__tstate);
29047 if (PyErr_Occurred()) SWIG_fail;
29048 }
29049 Py_INCREF(Py_None); resultobj = Py_None;
29050 return resultobj;
29051 fail:
29052 return NULL;
29053 }
29054
29055
29056 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29057 PyObject *resultobj;
29058 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29059 wxDataObject *result;
29060 PyObject * obj0 = 0 ;
29061 char *kwnames[] = {
29062 (char *) "self", NULL
29063 };
29064
29065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
29066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29067 if (SWIG_arg_fail(1)) SWIG_fail;
29068 {
29069 PyThreadState* __tstate = wxPyBeginAllowThreads();
29070 result = (wxDataObject *)(arg1)->GetDataObject();
29071
29072 wxPyEndAllowThreads(__tstate);
29073 if (PyErr_Occurred()) SWIG_fail;
29074 }
29075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29076 return resultobj;
29077 fail:
29078 return NULL;
29079 }
29080
29081
29082 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29083 PyObject *resultobj;
29084 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29085 wxDataObject *arg2 = (wxDataObject *) 0 ;
29086 PyObject * obj0 = 0 ;
29087 PyObject * obj1 = 0 ;
29088 char *kwnames[] = {
29089 (char *) "self",(char *) "dataObject", NULL
29090 };
29091
29092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29094 if (SWIG_arg_fail(1)) SWIG_fail;
29095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29096 if (SWIG_arg_fail(2)) SWIG_fail;
29097 {
29098 PyThreadState* __tstate = wxPyBeginAllowThreads();
29099 (arg1)->SetDataObject(arg2);
29100
29101 wxPyEndAllowThreads(__tstate);
29102 if (PyErr_Occurred()) SWIG_fail;
29103 }
29104 Py_INCREF(Py_None); resultobj = Py_None;
29105 return resultobj;
29106 fail:
29107 return NULL;
29108 }
29109
29110
29111 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29112 PyObject *resultobj;
29113 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29114 int arg2 ;
29115 int arg3 ;
29116 wxDragResult arg4 ;
29117 wxDragResult result;
29118 PyObject * obj0 = 0 ;
29119 PyObject * obj1 = 0 ;
29120 PyObject * obj2 = 0 ;
29121 PyObject * obj3 = 0 ;
29122 char *kwnames[] = {
29123 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29124 };
29125
29126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29128 if (SWIG_arg_fail(1)) SWIG_fail;
29129 {
29130 arg2 = (int)(SWIG_As_int(obj1));
29131 if (SWIG_arg_fail(2)) SWIG_fail;
29132 }
29133 {
29134 arg3 = (int)(SWIG_As_int(obj2));
29135 if (SWIG_arg_fail(3)) SWIG_fail;
29136 }
29137 {
29138 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29139 if (SWIG_arg_fail(4)) SWIG_fail;
29140 }
29141 {
29142 PyThreadState* __tstate = wxPyBeginAllowThreads();
29143 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29144
29145 wxPyEndAllowThreads(__tstate);
29146 if (PyErr_Occurred()) SWIG_fail;
29147 }
29148 resultobj = SWIG_From_int((result));
29149 return resultobj;
29150 fail:
29151 return NULL;
29152 }
29153
29154
29155 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29156 PyObject *resultobj;
29157 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29158 int arg2 ;
29159 int arg3 ;
29160 wxDragResult arg4 ;
29161 wxDragResult result;
29162 PyObject * obj0 = 0 ;
29163 PyObject * obj1 = 0 ;
29164 PyObject * obj2 = 0 ;
29165 PyObject * obj3 = 0 ;
29166 char *kwnames[] = {
29167 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29168 };
29169
29170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29172 if (SWIG_arg_fail(1)) SWIG_fail;
29173 {
29174 arg2 = (int)(SWIG_As_int(obj1));
29175 if (SWIG_arg_fail(2)) SWIG_fail;
29176 }
29177 {
29178 arg3 = (int)(SWIG_As_int(obj2));
29179 if (SWIG_arg_fail(3)) SWIG_fail;
29180 }
29181 {
29182 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29183 if (SWIG_arg_fail(4)) SWIG_fail;
29184 }
29185 {
29186 PyThreadState* __tstate = wxPyBeginAllowThreads();
29187 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29188
29189 wxPyEndAllowThreads(__tstate);
29190 if (PyErr_Occurred()) SWIG_fail;
29191 }
29192 resultobj = SWIG_From_int((result));
29193 return resultobj;
29194 fail:
29195 return NULL;
29196 }
29197
29198
29199 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29200 PyObject *resultobj;
29201 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29202 PyObject * obj0 = 0 ;
29203 char *kwnames[] = {
29204 (char *) "self", NULL
29205 };
29206
29207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29209 if (SWIG_arg_fail(1)) SWIG_fail;
29210 {
29211 PyThreadState* __tstate = wxPyBeginAllowThreads();
29212 (arg1)->base_OnLeave();
29213
29214 wxPyEndAllowThreads(__tstate);
29215 if (PyErr_Occurred()) SWIG_fail;
29216 }
29217 Py_INCREF(Py_None); resultobj = Py_None;
29218 return resultobj;
29219 fail:
29220 return NULL;
29221 }
29222
29223
29224 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29225 PyObject *resultobj;
29226 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29227 int arg2 ;
29228 int arg3 ;
29229 bool result;
29230 PyObject * obj0 = 0 ;
29231 PyObject * obj1 = 0 ;
29232 PyObject * obj2 = 0 ;
29233 char *kwnames[] = {
29234 (char *) "self",(char *) "x",(char *) "y", NULL
29235 };
29236
29237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29239 if (SWIG_arg_fail(1)) SWIG_fail;
29240 {
29241 arg2 = (int)(SWIG_As_int(obj1));
29242 if (SWIG_arg_fail(2)) SWIG_fail;
29243 }
29244 {
29245 arg3 = (int)(SWIG_As_int(obj2));
29246 if (SWIG_arg_fail(3)) SWIG_fail;
29247 }
29248 {
29249 PyThreadState* __tstate = wxPyBeginAllowThreads();
29250 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29251
29252 wxPyEndAllowThreads(__tstate);
29253 if (PyErr_Occurred()) SWIG_fail;
29254 }
29255 {
29256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29257 }
29258 return resultobj;
29259 fail:
29260 return NULL;
29261 }
29262
29263
29264 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29265 PyObject *resultobj;
29266 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29267 bool result;
29268 PyObject * obj0 = 0 ;
29269 char *kwnames[] = {
29270 (char *) "self", NULL
29271 };
29272
29273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29275 if (SWIG_arg_fail(1)) SWIG_fail;
29276 {
29277 PyThreadState* __tstate = wxPyBeginAllowThreads();
29278 result = (bool)(arg1)->GetData();
29279
29280 wxPyEndAllowThreads(__tstate);
29281 if (PyErr_Occurred()) SWIG_fail;
29282 }
29283 {
29284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29285 }
29286 return resultobj;
29287 fail:
29288 return NULL;
29289 }
29290
29291
29292 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29293 PyObject *resultobj;
29294 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29295 wxDragResult arg2 ;
29296 PyObject * obj0 = 0 ;
29297 PyObject * obj1 = 0 ;
29298 char *kwnames[] = {
29299 (char *) "self",(char *) "action", NULL
29300 };
29301
29302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29304 if (SWIG_arg_fail(1)) SWIG_fail;
29305 {
29306 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29307 if (SWIG_arg_fail(2)) SWIG_fail;
29308 }
29309 {
29310 PyThreadState* __tstate = wxPyBeginAllowThreads();
29311 (arg1)->SetDefaultAction((wxDragResult )arg2);
29312
29313 wxPyEndAllowThreads(__tstate);
29314 if (PyErr_Occurred()) SWIG_fail;
29315 }
29316 Py_INCREF(Py_None); resultobj = Py_None;
29317 return resultobj;
29318 fail:
29319 return NULL;
29320 }
29321
29322
29323 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29324 PyObject *resultobj;
29325 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29326 wxDragResult result;
29327 PyObject * obj0 = 0 ;
29328 char *kwnames[] = {
29329 (char *) "self", NULL
29330 };
29331
29332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29334 if (SWIG_arg_fail(1)) SWIG_fail;
29335 {
29336 PyThreadState* __tstate = wxPyBeginAllowThreads();
29337 result = (wxDragResult)(arg1)->GetDefaultAction();
29338
29339 wxPyEndAllowThreads(__tstate);
29340 if (PyErr_Occurred()) SWIG_fail;
29341 }
29342 resultobj = SWIG_From_int((result));
29343 return resultobj;
29344 fail:
29345 return NULL;
29346 }
29347
29348
29349 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29350 PyObject *obj;
29351 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29352 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29353 Py_INCREF(obj);
29354 return Py_BuildValue((char *)"");
29355 }
29356 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29357 PyObject *resultobj;
29358 wxPyTextDropTarget *result;
29359 char *kwnames[] = {
29360 NULL
29361 };
29362
29363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29364 {
29365 PyThreadState* __tstate = wxPyBeginAllowThreads();
29366 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29367
29368 wxPyEndAllowThreads(__tstate);
29369 if (PyErr_Occurred()) SWIG_fail;
29370 }
29371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29372 return resultobj;
29373 fail:
29374 return NULL;
29375 }
29376
29377
29378 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29379 PyObject *resultobj;
29380 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29381 PyObject *arg2 = (PyObject *) 0 ;
29382 PyObject *arg3 = (PyObject *) 0 ;
29383 PyObject * obj0 = 0 ;
29384 PyObject * obj1 = 0 ;
29385 PyObject * obj2 = 0 ;
29386 char *kwnames[] = {
29387 (char *) "self",(char *) "self",(char *) "_class", NULL
29388 };
29389
29390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29392 if (SWIG_arg_fail(1)) SWIG_fail;
29393 arg2 = obj1;
29394 arg3 = obj2;
29395 {
29396 PyThreadState* __tstate = wxPyBeginAllowThreads();
29397 (arg1)->_setCallbackInfo(arg2,arg3);
29398
29399 wxPyEndAllowThreads(__tstate);
29400 if (PyErr_Occurred()) SWIG_fail;
29401 }
29402 Py_INCREF(Py_None); resultobj = Py_None;
29403 return resultobj;
29404 fail:
29405 return NULL;
29406 }
29407
29408
29409 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29410 PyObject *resultobj;
29411 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29412 int arg2 ;
29413 int arg3 ;
29414 wxDragResult arg4 ;
29415 wxDragResult result;
29416 PyObject * obj0 = 0 ;
29417 PyObject * obj1 = 0 ;
29418 PyObject * obj2 = 0 ;
29419 PyObject * obj3 = 0 ;
29420 char *kwnames[] = {
29421 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29422 };
29423
29424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29426 if (SWIG_arg_fail(1)) SWIG_fail;
29427 {
29428 arg2 = (int)(SWIG_As_int(obj1));
29429 if (SWIG_arg_fail(2)) SWIG_fail;
29430 }
29431 {
29432 arg3 = (int)(SWIG_As_int(obj2));
29433 if (SWIG_arg_fail(3)) SWIG_fail;
29434 }
29435 {
29436 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29437 if (SWIG_arg_fail(4)) SWIG_fail;
29438 }
29439 {
29440 PyThreadState* __tstate = wxPyBeginAllowThreads();
29441 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29442
29443 wxPyEndAllowThreads(__tstate);
29444 if (PyErr_Occurred()) SWIG_fail;
29445 }
29446 resultobj = SWIG_From_int((result));
29447 return resultobj;
29448 fail:
29449 return NULL;
29450 }
29451
29452
29453 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29454 PyObject *resultobj;
29455 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29456 int arg2 ;
29457 int arg3 ;
29458 wxDragResult arg4 ;
29459 wxDragResult result;
29460 PyObject * obj0 = 0 ;
29461 PyObject * obj1 = 0 ;
29462 PyObject * obj2 = 0 ;
29463 PyObject * obj3 = 0 ;
29464 char *kwnames[] = {
29465 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29466 };
29467
29468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29470 if (SWIG_arg_fail(1)) SWIG_fail;
29471 {
29472 arg2 = (int)(SWIG_As_int(obj1));
29473 if (SWIG_arg_fail(2)) SWIG_fail;
29474 }
29475 {
29476 arg3 = (int)(SWIG_As_int(obj2));
29477 if (SWIG_arg_fail(3)) SWIG_fail;
29478 }
29479 {
29480 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29481 if (SWIG_arg_fail(4)) SWIG_fail;
29482 }
29483 {
29484 PyThreadState* __tstate = wxPyBeginAllowThreads();
29485 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29486
29487 wxPyEndAllowThreads(__tstate);
29488 if (PyErr_Occurred()) SWIG_fail;
29489 }
29490 resultobj = SWIG_From_int((result));
29491 return resultobj;
29492 fail:
29493 return NULL;
29494 }
29495
29496
29497 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29498 PyObject *resultobj;
29499 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29500 PyObject * obj0 = 0 ;
29501 char *kwnames[] = {
29502 (char *) "self", NULL
29503 };
29504
29505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29507 if (SWIG_arg_fail(1)) SWIG_fail;
29508 {
29509 PyThreadState* __tstate = wxPyBeginAllowThreads();
29510 (arg1)->base_OnLeave();
29511
29512 wxPyEndAllowThreads(__tstate);
29513 if (PyErr_Occurred()) SWIG_fail;
29514 }
29515 Py_INCREF(Py_None); resultobj = Py_None;
29516 return resultobj;
29517 fail:
29518 return NULL;
29519 }
29520
29521
29522 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29523 PyObject *resultobj;
29524 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29525 int arg2 ;
29526 int arg3 ;
29527 bool result;
29528 PyObject * obj0 = 0 ;
29529 PyObject * obj1 = 0 ;
29530 PyObject * obj2 = 0 ;
29531 char *kwnames[] = {
29532 (char *) "self",(char *) "x",(char *) "y", NULL
29533 };
29534
29535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29537 if (SWIG_arg_fail(1)) SWIG_fail;
29538 {
29539 arg2 = (int)(SWIG_As_int(obj1));
29540 if (SWIG_arg_fail(2)) SWIG_fail;
29541 }
29542 {
29543 arg3 = (int)(SWIG_As_int(obj2));
29544 if (SWIG_arg_fail(3)) SWIG_fail;
29545 }
29546 {
29547 PyThreadState* __tstate = wxPyBeginAllowThreads();
29548 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29549
29550 wxPyEndAllowThreads(__tstate);
29551 if (PyErr_Occurred()) SWIG_fail;
29552 }
29553 {
29554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29555 }
29556 return resultobj;
29557 fail:
29558 return NULL;
29559 }
29560
29561
29562 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29563 PyObject *resultobj;
29564 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29565 int arg2 ;
29566 int arg3 ;
29567 wxDragResult arg4 ;
29568 wxDragResult result;
29569 PyObject * obj0 = 0 ;
29570 PyObject * obj1 = 0 ;
29571 PyObject * obj2 = 0 ;
29572 PyObject * obj3 = 0 ;
29573 char *kwnames[] = {
29574 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29575 };
29576
29577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29579 if (SWIG_arg_fail(1)) SWIG_fail;
29580 {
29581 arg2 = (int)(SWIG_As_int(obj1));
29582 if (SWIG_arg_fail(2)) SWIG_fail;
29583 }
29584 {
29585 arg3 = (int)(SWIG_As_int(obj2));
29586 if (SWIG_arg_fail(3)) SWIG_fail;
29587 }
29588 {
29589 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29590 if (SWIG_arg_fail(4)) SWIG_fail;
29591 }
29592 {
29593 PyThreadState* __tstate = wxPyBeginAllowThreads();
29594 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29595
29596 wxPyEndAllowThreads(__tstate);
29597 if (PyErr_Occurred()) SWIG_fail;
29598 }
29599 resultobj = SWIG_From_int((result));
29600 return resultobj;
29601 fail:
29602 return NULL;
29603 }
29604
29605
29606 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29607 PyObject *obj;
29608 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29609 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29610 Py_INCREF(obj);
29611 return Py_BuildValue((char *)"");
29612 }
29613 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29614 PyObject *resultobj;
29615 wxPyFileDropTarget *result;
29616 char *kwnames[] = {
29617 NULL
29618 };
29619
29620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29621 {
29622 PyThreadState* __tstate = wxPyBeginAllowThreads();
29623 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29624
29625 wxPyEndAllowThreads(__tstate);
29626 if (PyErr_Occurred()) SWIG_fail;
29627 }
29628 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29629 return resultobj;
29630 fail:
29631 return NULL;
29632 }
29633
29634
29635 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29636 PyObject *resultobj;
29637 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29638 PyObject *arg2 = (PyObject *) 0 ;
29639 PyObject *arg3 = (PyObject *) 0 ;
29640 PyObject * obj0 = 0 ;
29641 PyObject * obj1 = 0 ;
29642 PyObject * obj2 = 0 ;
29643 char *kwnames[] = {
29644 (char *) "self",(char *) "self",(char *) "_class", NULL
29645 };
29646
29647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29649 if (SWIG_arg_fail(1)) SWIG_fail;
29650 arg2 = obj1;
29651 arg3 = obj2;
29652 {
29653 PyThreadState* __tstate = wxPyBeginAllowThreads();
29654 (arg1)->_setCallbackInfo(arg2,arg3);
29655
29656 wxPyEndAllowThreads(__tstate);
29657 if (PyErr_Occurred()) SWIG_fail;
29658 }
29659 Py_INCREF(Py_None); resultobj = Py_None;
29660 return resultobj;
29661 fail:
29662 return NULL;
29663 }
29664
29665
29666 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29667 PyObject *resultobj;
29668 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29669 int arg2 ;
29670 int arg3 ;
29671 wxDragResult arg4 ;
29672 wxDragResult result;
29673 PyObject * obj0 = 0 ;
29674 PyObject * obj1 = 0 ;
29675 PyObject * obj2 = 0 ;
29676 PyObject * obj3 = 0 ;
29677 char *kwnames[] = {
29678 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29679 };
29680
29681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29683 if (SWIG_arg_fail(1)) SWIG_fail;
29684 {
29685 arg2 = (int)(SWIG_As_int(obj1));
29686 if (SWIG_arg_fail(2)) SWIG_fail;
29687 }
29688 {
29689 arg3 = (int)(SWIG_As_int(obj2));
29690 if (SWIG_arg_fail(3)) SWIG_fail;
29691 }
29692 {
29693 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29694 if (SWIG_arg_fail(4)) SWIG_fail;
29695 }
29696 {
29697 PyThreadState* __tstate = wxPyBeginAllowThreads();
29698 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29699
29700 wxPyEndAllowThreads(__tstate);
29701 if (PyErr_Occurred()) SWIG_fail;
29702 }
29703 resultobj = SWIG_From_int((result));
29704 return resultobj;
29705 fail:
29706 return NULL;
29707 }
29708
29709
29710 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29711 PyObject *resultobj;
29712 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29713 int arg2 ;
29714 int arg3 ;
29715 wxDragResult arg4 ;
29716 wxDragResult result;
29717 PyObject * obj0 = 0 ;
29718 PyObject * obj1 = 0 ;
29719 PyObject * obj2 = 0 ;
29720 PyObject * obj3 = 0 ;
29721 char *kwnames[] = {
29722 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29723 };
29724
29725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29727 if (SWIG_arg_fail(1)) SWIG_fail;
29728 {
29729 arg2 = (int)(SWIG_As_int(obj1));
29730 if (SWIG_arg_fail(2)) SWIG_fail;
29731 }
29732 {
29733 arg3 = (int)(SWIG_As_int(obj2));
29734 if (SWIG_arg_fail(3)) SWIG_fail;
29735 }
29736 {
29737 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29738 if (SWIG_arg_fail(4)) SWIG_fail;
29739 }
29740 {
29741 PyThreadState* __tstate = wxPyBeginAllowThreads();
29742 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29743
29744 wxPyEndAllowThreads(__tstate);
29745 if (PyErr_Occurred()) SWIG_fail;
29746 }
29747 resultobj = SWIG_From_int((result));
29748 return resultobj;
29749 fail:
29750 return NULL;
29751 }
29752
29753
29754 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29755 PyObject *resultobj;
29756 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29757 PyObject * obj0 = 0 ;
29758 char *kwnames[] = {
29759 (char *) "self", NULL
29760 };
29761
29762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29764 if (SWIG_arg_fail(1)) SWIG_fail;
29765 {
29766 PyThreadState* __tstate = wxPyBeginAllowThreads();
29767 (arg1)->base_OnLeave();
29768
29769 wxPyEndAllowThreads(__tstate);
29770 if (PyErr_Occurred()) SWIG_fail;
29771 }
29772 Py_INCREF(Py_None); resultobj = Py_None;
29773 return resultobj;
29774 fail:
29775 return NULL;
29776 }
29777
29778
29779 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29780 PyObject *resultobj;
29781 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29782 int arg2 ;
29783 int arg3 ;
29784 bool result;
29785 PyObject * obj0 = 0 ;
29786 PyObject * obj1 = 0 ;
29787 PyObject * obj2 = 0 ;
29788 char *kwnames[] = {
29789 (char *) "self",(char *) "x",(char *) "y", NULL
29790 };
29791
29792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29794 if (SWIG_arg_fail(1)) SWIG_fail;
29795 {
29796 arg2 = (int)(SWIG_As_int(obj1));
29797 if (SWIG_arg_fail(2)) SWIG_fail;
29798 }
29799 {
29800 arg3 = (int)(SWIG_As_int(obj2));
29801 if (SWIG_arg_fail(3)) SWIG_fail;
29802 }
29803 {
29804 PyThreadState* __tstate = wxPyBeginAllowThreads();
29805 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29806
29807 wxPyEndAllowThreads(__tstate);
29808 if (PyErr_Occurred()) SWIG_fail;
29809 }
29810 {
29811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29812 }
29813 return resultobj;
29814 fail:
29815 return NULL;
29816 }
29817
29818
29819 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29820 PyObject *resultobj;
29821 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29822 int arg2 ;
29823 int arg3 ;
29824 wxDragResult arg4 ;
29825 wxDragResult result;
29826 PyObject * obj0 = 0 ;
29827 PyObject * obj1 = 0 ;
29828 PyObject * obj2 = 0 ;
29829 PyObject * obj3 = 0 ;
29830 char *kwnames[] = {
29831 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29832 };
29833
29834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29836 if (SWIG_arg_fail(1)) SWIG_fail;
29837 {
29838 arg2 = (int)(SWIG_As_int(obj1));
29839 if (SWIG_arg_fail(2)) SWIG_fail;
29840 }
29841 {
29842 arg3 = (int)(SWIG_As_int(obj2));
29843 if (SWIG_arg_fail(3)) SWIG_fail;
29844 }
29845 {
29846 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29847 if (SWIG_arg_fail(4)) SWIG_fail;
29848 }
29849 {
29850 PyThreadState* __tstate = wxPyBeginAllowThreads();
29851 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29852
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 resultobj = SWIG_From_int((result));
29857 return resultobj;
29858 fail:
29859 return NULL;
29860 }
29861
29862
29863 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29864 PyObject *obj;
29865 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29866 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29867 Py_INCREF(obj);
29868 return Py_BuildValue((char *)"");
29869 }
29870 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29871 PyObject *resultobj;
29872 wxClipboard *result;
29873 char *kwnames[] = {
29874 NULL
29875 };
29876
29877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29878 {
29879 PyThreadState* __tstate = wxPyBeginAllowThreads();
29880 result = (wxClipboard *)new wxClipboard();
29881
29882 wxPyEndAllowThreads(__tstate);
29883 if (PyErr_Occurred()) SWIG_fail;
29884 }
29885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29886 return resultobj;
29887 fail:
29888 return NULL;
29889 }
29890
29891
29892 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29893 PyObject *resultobj;
29894 wxClipboard *arg1 = (wxClipboard *) 0 ;
29895 PyObject * obj0 = 0 ;
29896 char *kwnames[] = {
29897 (char *) "self", NULL
29898 };
29899
29900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29902 if (SWIG_arg_fail(1)) SWIG_fail;
29903 {
29904 PyThreadState* __tstate = wxPyBeginAllowThreads();
29905 delete arg1;
29906
29907 wxPyEndAllowThreads(__tstate);
29908 if (PyErr_Occurred()) SWIG_fail;
29909 }
29910 Py_INCREF(Py_None); resultobj = Py_None;
29911 return resultobj;
29912 fail:
29913 return NULL;
29914 }
29915
29916
29917 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29918 PyObject *resultobj;
29919 wxClipboard *arg1 = (wxClipboard *) 0 ;
29920 bool result;
29921 PyObject * obj0 = 0 ;
29922 char *kwnames[] = {
29923 (char *) "self", NULL
29924 };
29925
29926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29928 if (SWIG_arg_fail(1)) SWIG_fail;
29929 {
29930 PyThreadState* __tstate = wxPyBeginAllowThreads();
29931 result = (bool)(arg1)->Open();
29932
29933 wxPyEndAllowThreads(__tstate);
29934 if (PyErr_Occurred()) SWIG_fail;
29935 }
29936 {
29937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29938 }
29939 return resultobj;
29940 fail:
29941 return NULL;
29942 }
29943
29944
29945 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29946 PyObject *resultobj;
29947 wxClipboard *arg1 = (wxClipboard *) 0 ;
29948 PyObject * obj0 = 0 ;
29949 char *kwnames[] = {
29950 (char *) "self", NULL
29951 };
29952
29953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29955 if (SWIG_arg_fail(1)) SWIG_fail;
29956 {
29957 PyThreadState* __tstate = wxPyBeginAllowThreads();
29958 (arg1)->Close();
29959
29960 wxPyEndAllowThreads(__tstate);
29961 if (PyErr_Occurred()) SWIG_fail;
29962 }
29963 Py_INCREF(Py_None); resultobj = Py_None;
29964 return resultobj;
29965 fail:
29966 return NULL;
29967 }
29968
29969
29970 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29971 PyObject *resultobj;
29972 wxClipboard *arg1 = (wxClipboard *) 0 ;
29973 bool result;
29974 PyObject * obj0 = 0 ;
29975 char *kwnames[] = {
29976 (char *) "self", NULL
29977 };
29978
29979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29981 if (SWIG_arg_fail(1)) SWIG_fail;
29982 {
29983 PyThreadState* __tstate = wxPyBeginAllowThreads();
29984 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29985
29986 wxPyEndAllowThreads(__tstate);
29987 if (PyErr_Occurred()) SWIG_fail;
29988 }
29989 {
29990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29991 }
29992 return resultobj;
29993 fail:
29994 return NULL;
29995 }
29996
29997
29998 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29999 PyObject *resultobj;
30000 wxClipboard *arg1 = (wxClipboard *) 0 ;
30001 wxDataObject *arg2 = (wxDataObject *) 0 ;
30002 bool result;
30003 PyObject * obj0 = 0 ;
30004 PyObject * obj1 = 0 ;
30005 char *kwnames[] = {
30006 (char *) "self",(char *) "data", NULL
30007 };
30008
30009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
30010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30011 if (SWIG_arg_fail(1)) SWIG_fail;
30012 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30013 if (SWIG_arg_fail(2)) SWIG_fail;
30014 {
30015 PyThreadState* __tstate = wxPyBeginAllowThreads();
30016 result = (bool)(arg1)->AddData(arg2);
30017
30018 wxPyEndAllowThreads(__tstate);
30019 if (PyErr_Occurred()) SWIG_fail;
30020 }
30021 {
30022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30023 }
30024 return resultobj;
30025 fail:
30026 return NULL;
30027 }
30028
30029
30030 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
30031 PyObject *resultobj;
30032 wxClipboard *arg1 = (wxClipboard *) 0 ;
30033 wxDataObject *arg2 = (wxDataObject *) 0 ;
30034 bool result;
30035 PyObject * obj0 = 0 ;
30036 PyObject * obj1 = 0 ;
30037 char *kwnames[] = {
30038 (char *) "self",(char *) "data", NULL
30039 };
30040
30041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
30042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30043 if (SWIG_arg_fail(1)) SWIG_fail;
30044 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30045 if (SWIG_arg_fail(2)) SWIG_fail;
30046 {
30047 PyThreadState* __tstate = wxPyBeginAllowThreads();
30048 result = (bool)(arg1)->SetData(arg2);
30049
30050 wxPyEndAllowThreads(__tstate);
30051 if (PyErr_Occurred()) SWIG_fail;
30052 }
30053 {
30054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30055 }
30056 return resultobj;
30057 fail:
30058 return NULL;
30059 }
30060
30061
30062 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
30063 PyObject *resultobj;
30064 wxClipboard *arg1 = (wxClipboard *) 0 ;
30065 wxDataFormat *arg2 = 0 ;
30066 bool result;
30067 PyObject * obj0 = 0 ;
30068 PyObject * obj1 = 0 ;
30069 char *kwnames[] = {
30070 (char *) "self",(char *) "format", NULL
30071 };
30072
30073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
30074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30075 if (SWIG_arg_fail(1)) SWIG_fail;
30076 {
30077 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
30078 if (SWIG_arg_fail(2)) SWIG_fail;
30079 if (arg2 == NULL) {
30080 SWIG_null_ref("wxDataFormat");
30081 }
30082 if (SWIG_arg_fail(2)) SWIG_fail;
30083 }
30084 {
30085 PyThreadState* __tstate = wxPyBeginAllowThreads();
30086 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
30087
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 {
30092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30093 }
30094 return resultobj;
30095 fail:
30096 return NULL;
30097 }
30098
30099
30100 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30101 PyObject *resultobj;
30102 wxClipboard *arg1 = (wxClipboard *) 0 ;
30103 wxDataObject *arg2 = 0 ;
30104 bool result;
30105 PyObject * obj0 = 0 ;
30106 PyObject * obj1 = 0 ;
30107 char *kwnames[] = {
30108 (char *) "self",(char *) "data", NULL
30109 };
30110
30111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30113 if (SWIG_arg_fail(1)) SWIG_fail;
30114 {
30115 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30116 if (SWIG_arg_fail(2)) SWIG_fail;
30117 if (arg2 == NULL) {
30118 SWIG_null_ref("wxDataObject");
30119 }
30120 if (SWIG_arg_fail(2)) SWIG_fail;
30121 }
30122 {
30123 PyThreadState* __tstate = wxPyBeginAllowThreads();
30124 result = (bool)(arg1)->GetData(*arg2);
30125
30126 wxPyEndAllowThreads(__tstate);
30127 if (PyErr_Occurred()) SWIG_fail;
30128 }
30129 {
30130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30131 }
30132 return resultobj;
30133 fail:
30134 return NULL;
30135 }
30136
30137
30138 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30139 PyObject *resultobj;
30140 wxClipboard *arg1 = (wxClipboard *) 0 ;
30141 PyObject * obj0 = 0 ;
30142 char *kwnames[] = {
30143 (char *) "self", NULL
30144 };
30145
30146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30148 if (SWIG_arg_fail(1)) SWIG_fail;
30149 {
30150 PyThreadState* __tstate = wxPyBeginAllowThreads();
30151 (arg1)->Clear();
30152
30153 wxPyEndAllowThreads(__tstate);
30154 if (PyErr_Occurred()) SWIG_fail;
30155 }
30156 Py_INCREF(Py_None); resultobj = Py_None;
30157 return resultobj;
30158 fail:
30159 return NULL;
30160 }
30161
30162
30163 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30164 PyObject *resultobj;
30165 wxClipboard *arg1 = (wxClipboard *) 0 ;
30166 bool result;
30167 PyObject * obj0 = 0 ;
30168 char *kwnames[] = {
30169 (char *) "self", NULL
30170 };
30171
30172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30174 if (SWIG_arg_fail(1)) SWIG_fail;
30175 {
30176 PyThreadState* __tstate = wxPyBeginAllowThreads();
30177 result = (bool)(arg1)->Flush();
30178
30179 wxPyEndAllowThreads(__tstate);
30180 if (PyErr_Occurred()) SWIG_fail;
30181 }
30182 {
30183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30184 }
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30192 PyObject *resultobj;
30193 wxClipboard *arg1 = (wxClipboard *) 0 ;
30194 bool arg2 = (bool) true ;
30195 PyObject * obj0 = 0 ;
30196 PyObject * obj1 = 0 ;
30197 char *kwnames[] = {
30198 (char *) "self",(char *) "primary", NULL
30199 };
30200
30201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30203 if (SWIG_arg_fail(1)) SWIG_fail;
30204 if (obj1) {
30205 {
30206 arg2 = (bool)(SWIG_As_bool(obj1));
30207 if (SWIG_arg_fail(2)) SWIG_fail;
30208 }
30209 }
30210 {
30211 PyThreadState* __tstate = wxPyBeginAllowThreads();
30212 (arg1)->UsePrimarySelection(arg2);
30213
30214 wxPyEndAllowThreads(__tstate);
30215 if (PyErr_Occurred()) SWIG_fail;
30216 }
30217 Py_INCREF(Py_None); resultobj = Py_None;
30218 return resultobj;
30219 fail:
30220 return NULL;
30221 }
30222
30223
30224 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30225 PyObject *resultobj;
30226 wxClipboard *result;
30227 char *kwnames[] = {
30228 NULL
30229 };
30230
30231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30232 {
30233 PyThreadState* __tstate = wxPyBeginAllowThreads();
30234 result = (wxClipboard *)wxClipboard::Get();
30235
30236 wxPyEndAllowThreads(__tstate);
30237 if (PyErr_Occurred()) SWIG_fail;
30238 }
30239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30240 return resultobj;
30241 fail:
30242 return NULL;
30243 }
30244
30245
30246 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30247 PyObject *obj;
30248 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30249 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30250 Py_INCREF(obj);
30251 return Py_BuildValue((char *)"");
30252 }
30253 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30254 PyObject *resultobj;
30255 wxClipboard *arg1 = (wxClipboard *) NULL ;
30256 wxClipboardLocker *result;
30257 PyObject * obj0 = 0 ;
30258 char *kwnames[] = {
30259 (char *) "clipboard", NULL
30260 };
30261
30262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30263 if (obj0) {
30264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30265 if (SWIG_arg_fail(1)) SWIG_fail;
30266 }
30267 {
30268 PyThreadState* __tstate = wxPyBeginAllowThreads();
30269 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30270
30271 wxPyEndAllowThreads(__tstate);
30272 if (PyErr_Occurred()) SWIG_fail;
30273 }
30274 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30275 return resultobj;
30276 fail:
30277 return NULL;
30278 }
30279
30280
30281 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30282 PyObject *resultobj;
30283 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30284 PyObject * obj0 = 0 ;
30285 char *kwnames[] = {
30286 (char *) "self", NULL
30287 };
30288
30289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30291 if (SWIG_arg_fail(1)) SWIG_fail;
30292 {
30293 PyThreadState* __tstate = wxPyBeginAllowThreads();
30294 delete arg1;
30295
30296 wxPyEndAllowThreads(__tstate);
30297 if (PyErr_Occurred()) SWIG_fail;
30298 }
30299 Py_INCREF(Py_None); resultobj = Py_None;
30300 return resultobj;
30301 fail:
30302 return NULL;
30303 }
30304
30305
30306 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30307 PyObject *resultobj;
30308 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30309 bool result;
30310 PyObject * obj0 = 0 ;
30311 char *kwnames[] = {
30312 (char *) "self", NULL
30313 };
30314
30315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30317 if (SWIG_arg_fail(1)) SWIG_fail;
30318 {
30319 PyThreadState* __tstate = wxPyBeginAllowThreads();
30320 result = (bool)wxClipboardLocker___nonzero__(arg1);
30321
30322 wxPyEndAllowThreads(__tstate);
30323 if (PyErr_Occurred()) SWIG_fail;
30324 }
30325 {
30326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30327 }
30328 return resultobj;
30329 fail:
30330 return NULL;
30331 }
30332
30333
30334 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30335 PyObject *obj;
30336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30337 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30338 Py_INCREF(obj);
30339 return Py_BuildValue((char *)"");
30340 }
30341 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30342 PyObject *resultobj;
30343 int arg1 = (int) 0 ;
30344 int arg2 = (int) 0 ;
30345 int arg3 = (int) 0 ;
30346 int arg4 = (int) 0 ;
30347 wxVideoMode *result;
30348 PyObject * obj0 = 0 ;
30349 PyObject * obj1 = 0 ;
30350 PyObject * obj2 = 0 ;
30351 PyObject * obj3 = 0 ;
30352 char *kwnames[] = {
30353 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30354 };
30355
30356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30357 if (obj0) {
30358 {
30359 arg1 = (int)(SWIG_As_int(obj0));
30360 if (SWIG_arg_fail(1)) SWIG_fail;
30361 }
30362 }
30363 if (obj1) {
30364 {
30365 arg2 = (int)(SWIG_As_int(obj1));
30366 if (SWIG_arg_fail(2)) SWIG_fail;
30367 }
30368 }
30369 if (obj2) {
30370 {
30371 arg3 = (int)(SWIG_As_int(obj2));
30372 if (SWIG_arg_fail(3)) SWIG_fail;
30373 }
30374 }
30375 if (obj3) {
30376 {
30377 arg4 = (int)(SWIG_As_int(obj3));
30378 if (SWIG_arg_fail(4)) SWIG_fail;
30379 }
30380 }
30381 {
30382 PyThreadState* __tstate = wxPyBeginAllowThreads();
30383 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30384
30385 wxPyEndAllowThreads(__tstate);
30386 if (PyErr_Occurred()) SWIG_fail;
30387 }
30388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30389 return resultobj;
30390 fail:
30391 return NULL;
30392 }
30393
30394
30395 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30396 PyObject *resultobj;
30397 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30398 PyObject * obj0 = 0 ;
30399 char *kwnames[] = {
30400 (char *) "self", NULL
30401 };
30402
30403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30405 if (SWIG_arg_fail(1)) SWIG_fail;
30406 {
30407 PyThreadState* __tstate = wxPyBeginAllowThreads();
30408 delete arg1;
30409
30410 wxPyEndAllowThreads(__tstate);
30411 if (PyErr_Occurred()) SWIG_fail;
30412 }
30413 Py_INCREF(Py_None); resultobj = Py_None;
30414 return resultobj;
30415 fail:
30416 return NULL;
30417 }
30418
30419
30420 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30421 PyObject *resultobj;
30422 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30423 wxVideoMode *arg2 = 0 ;
30424 bool result;
30425 PyObject * obj0 = 0 ;
30426 PyObject * obj1 = 0 ;
30427 char *kwnames[] = {
30428 (char *) "self",(char *) "other", NULL
30429 };
30430
30431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30433 if (SWIG_arg_fail(1)) SWIG_fail;
30434 {
30435 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30436 if (SWIG_arg_fail(2)) SWIG_fail;
30437 if (arg2 == NULL) {
30438 SWIG_null_ref("wxVideoMode");
30439 }
30440 if (SWIG_arg_fail(2)) SWIG_fail;
30441 }
30442 {
30443 PyThreadState* __tstate = wxPyBeginAllowThreads();
30444 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30445
30446 wxPyEndAllowThreads(__tstate);
30447 if (PyErr_Occurred()) SWIG_fail;
30448 }
30449 {
30450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30451 }
30452 return resultobj;
30453 fail:
30454 return NULL;
30455 }
30456
30457
30458 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30459 PyObject *resultobj;
30460 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30461 int result;
30462 PyObject * obj0 = 0 ;
30463 char *kwnames[] = {
30464 (char *) "self", NULL
30465 };
30466
30467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30469 if (SWIG_arg_fail(1)) SWIG_fail;
30470 {
30471 PyThreadState* __tstate = wxPyBeginAllowThreads();
30472 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30473
30474 wxPyEndAllowThreads(__tstate);
30475 if (PyErr_Occurred()) SWIG_fail;
30476 }
30477 {
30478 resultobj = SWIG_From_int((int)(result));
30479 }
30480 return resultobj;
30481 fail:
30482 return NULL;
30483 }
30484
30485
30486 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30487 PyObject *resultobj;
30488 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30489 int result;
30490 PyObject * obj0 = 0 ;
30491 char *kwnames[] = {
30492 (char *) "self", NULL
30493 };
30494
30495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30497 if (SWIG_arg_fail(1)) SWIG_fail;
30498 {
30499 PyThreadState* __tstate = wxPyBeginAllowThreads();
30500 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30501
30502 wxPyEndAllowThreads(__tstate);
30503 if (PyErr_Occurred()) SWIG_fail;
30504 }
30505 {
30506 resultobj = SWIG_From_int((int)(result));
30507 }
30508 return resultobj;
30509 fail:
30510 return NULL;
30511 }
30512
30513
30514 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30515 PyObject *resultobj;
30516 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30517 int result;
30518 PyObject * obj0 = 0 ;
30519 char *kwnames[] = {
30520 (char *) "self", NULL
30521 };
30522
30523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30525 if (SWIG_arg_fail(1)) SWIG_fail;
30526 {
30527 PyThreadState* __tstate = wxPyBeginAllowThreads();
30528 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30529
30530 wxPyEndAllowThreads(__tstate);
30531 if (PyErr_Occurred()) SWIG_fail;
30532 }
30533 {
30534 resultobj = SWIG_From_int((int)(result));
30535 }
30536 return resultobj;
30537 fail:
30538 return NULL;
30539 }
30540
30541
30542 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30543 PyObject *resultobj;
30544 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30545 bool result;
30546 PyObject * obj0 = 0 ;
30547 char *kwnames[] = {
30548 (char *) "self", NULL
30549 };
30550
30551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30553 if (SWIG_arg_fail(1)) SWIG_fail;
30554 {
30555 PyThreadState* __tstate = wxPyBeginAllowThreads();
30556 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30557
30558 wxPyEndAllowThreads(__tstate);
30559 if (PyErr_Occurred()) SWIG_fail;
30560 }
30561 {
30562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30563 }
30564 return resultobj;
30565 fail:
30566 return NULL;
30567 }
30568
30569
30570 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30571 PyObject *resultobj;
30572 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30573 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30574 bool result;
30575 PyObject * obj0 = 0 ;
30576 PyObject * obj1 = 0 ;
30577 char *kwnames[] = {
30578 (char *) "self",(char *) "other", NULL
30579 };
30580
30581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30583 if (SWIG_arg_fail(1)) SWIG_fail;
30584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30585 if (SWIG_arg_fail(2)) SWIG_fail;
30586 {
30587 PyThreadState* __tstate = wxPyBeginAllowThreads();
30588 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30589
30590 wxPyEndAllowThreads(__tstate);
30591 if (PyErr_Occurred()) SWIG_fail;
30592 }
30593 {
30594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30595 }
30596 return resultobj;
30597 fail:
30598 return NULL;
30599 }
30600
30601
30602 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30603 PyObject *resultobj;
30604 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30605 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30606 bool result;
30607 PyObject * obj0 = 0 ;
30608 PyObject * obj1 = 0 ;
30609 char *kwnames[] = {
30610 (char *) "self",(char *) "other", NULL
30611 };
30612
30613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30615 if (SWIG_arg_fail(1)) SWIG_fail;
30616 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30617 if (SWIG_arg_fail(2)) SWIG_fail;
30618 {
30619 PyThreadState* __tstate = wxPyBeginAllowThreads();
30620 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30621
30622 wxPyEndAllowThreads(__tstate);
30623 if (PyErr_Occurred()) SWIG_fail;
30624 }
30625 {
30626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30627 }
30628 return resultobj;
30629 fail:
30630 return NULL;
30631 }
30632
30633
30634 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30635 PyObject *resultobj;
30636 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30637 int arg2 ;
30638 PyObject * obj0 = 0 ;
30639 PyObject * obj1 = 0 ;
30640 char *kwnames[] = {
30641 (char *) "self",(char *) "w", NULL
30642 };
30643
30644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30646 if (SWIG_arg_fail(1)) SWIG_fail;
30647 {
30648 arg2 = (int)(SWIG_As_int(obj1));
30649 if (SWIG_arg_fail(2)) SWIG_fail;
30650 }
30651 if (arg1) (arg1)->w = arg2;
30652
30653 Py_INCREF(Py_None); resultobj = Py_None;
30654 return resultobj;
30655 fail:
30656 return NULL;
30657 }
30658
30659
30660 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30661 PyObject *resultobj;
30662 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30663 int result;
30664 PyObject * obj0 = 0 ;
30665 char *kwnames[] = {
30666 (char *) "self", NULL
30667 };
30668
30669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30671 if (SWIG_arg_fail(1)) SWIG_fail;
30672 result = (int) ((arg1)->w);
30673
30674 {
30675 resultobj = SWIG_From_int((int)(result));
30676 }
30677 return resultobj;
30678 fail:
30679 return NULL;
30680 }
30681
30682
30683 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30684 PyObject *resultobj;
30685 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30686 int arg2 ;
30687 PyObject * obj0 = 0 ;
30688 PyObject * obj1 = 0 ;
30689 char *kwnames[] = {
30690 (char *) "self",(char *) "h", NULL
30691 };
30692
30693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30695 if (SWIG_arg_fail(1)) SWIG_fail;
30696 {
30697 arg2 = (int)(SWIG_As_int(obj1));
30698 if (SWIG_arg_fail(2)) SWIG_fail;
30699 }
30700 if (arg1) (arg1)->h = arg2;
30701
30702 Py_INCREF(Py_None); resultobj = Py_None;
30703 return resultobj;
30704 fail:
30705 return NULL;
30706 }
30707
30708
30709 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30710 PyObject *resultobj;
30711 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30712 int result;
30713 PyObject * obj0 = 0 ;
30714 char *kwnames[] = {
30715 (char *) "self", NULL
30716 };
30717
30718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30720 if (SWIG_arg_fail(1)) SWIG_fail;
30721 result = (int) ((arg1)->h);
30722
30723 {
30724 resultobj = SWIG_From_int((int)(result));
30725 }
30726 return resultobj;
30727 fail:
30728 return NULL;
30729 }
30730
30731
30732 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30733 PyObject *resultobj;
30734 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30735 int arg2 ;
30736 PyObject * obj0 = 0 ;
30737 PyObject * obj1 = 0 ;
30738 char *kwnames[] = {
30739 (char *) "self",(char *) "bpp", NULL
30740 };
30741
30742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30744 if (SWIG_arg_fail(1)) SWIG_fail;
30745 {
30746 arg2 = (int)(SWIG_As_int(obj1));
30747 if (SWIG_arg_fail(2)) SWIG_fail;
30748 }
30749 if (arg1) (arg1)->bpp = arg2;
30750
30751 Py_INCREF(Py_None); resultobj = Py_None;
30752 return resultobj;
30753 fail:
30754 return NULL;
30755 }
30756
30757
30758 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30759 PyObject *resultobj;
30760 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30761 int result;
30762 PyObject * obj0 = 0 ;
30763 char *kwnames[] = {
30764 (char *) "self", NULL
30765 };
30766
30767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30769 if (SWIG_arg_fail(1)) SWIG_fail;
30770 result = (int) ((arg1)->bpp);
30771
30772 {
30773 resultobj = SWIG_From_int((int)(result));
30774 }
30775 return resultobj;
30776 fail:
30777 return NULL;
30778 }
30779
30780
30781 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30782 PyObject *resultobj;
30783 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30784 int arg2 ;
30785 PyObject * obj0 = 0 ;
30786 PyObject * obj1 = 0 ;
30787 char *kwnames[] = {
30788 (char *) "self",(char *) "refresh", NULL
30789 };
30790
30791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30793 if (SWIG_arg_fail(1)) SWIG_fail;
30794 {
30795 arg2 = (int)(SWIG_As_int(obj1));
30796 if (SWIG_arg_fail(2)) SWIG_fail;
30797 }
30798 if (arg1) (arg1)->refresh = arg2;
30799
30800 Py_INCREF(Py_None); resultobj = Py_None;
30801 return resultobj;
30802 fail:
30803 return NULL;
30804 }
30805
30806
30807 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30808 PyObject *resultobj;
30809 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30810 int result;
30811 PyObject * obj0 = 0 ;
30812 char *kwnames[] = {
30813 (char *) "self", NULL
30814 };
30815
30816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30818 if (SWIG_arg_fail(1)) SWIG_fail;
30819 result = (int) ((arg1)->refresh);
30820
30821 {
30822 resultobj = SWIG_From_int((int)(result));
30823 }
30824 return resultobj;
30825 fail:
30826 return NULL;
30827 }
30828
30829
30830 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30831 PyObject *obj;
30832 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30833 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30834 Py_INCREF(obj);
30835 return Py_BuildValue((char *)"");
30836 }
30837 static int _wrap_DefaultVideoMode_set(PyObject *) {
30838 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30839 return 1;
30840 }
30841
30842
30843 static PyObject *_wrap_DefaultVideoMode_get(void) {
30844 PyObject *pyobj;
30845
30846 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30847 return pyobj;
30848 }
30849
30850
30851 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30852 PyObject *resultobj;
30853 size_t arg1 = (size_t) 0 ;
30854 wxDisplay *result;
30855 PyObject * obj0 = 0 ;
30856 char *kwnames[] = {
30857 (char *) "index", NULL
30858 };
30859
30860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30861 if (obj0) {
30862 {
30863 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30864 if (SWIG_arg_fail(1)) SWIG_fail;
30865 }
30866 }
30867 {
30868 PyThreadState* __tstate = wxPyBeginAllowThreads();
30869 result = (wxDisplay *)new wxDisplay(arg1);
30870
30871 wxPyEndAllowThreads(__tstate);
30872 if (PyErr_Occurred()) SWIG_fail;
30873 }
30874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30875 return resultobj;
30876 fail:
30877 return NULL;
30878 }
30879
30880
30881 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30882 PyObject *resultobj;
30883 wxDisplay *arg1 = (wxDisplay *) 0 ;
30884 PyObject * obj0 = 0 ;
30885 char *kwnames[] = {
30886 (char *) "self", NULL
30887 };
30888
30889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30891 if (SWIG_arg_fail(1)) SWIG_fail;
30892 {
30893 PyThreadState* __tstate = wxPyBeginAllowThreads();
30894 delete arg1;
30895
30896 wxPyEndAllowThreads(__tstate);
30897 if (PyErr_Occurred()) SWIG_fail;
30898 }
30899 Py_INCREF(Py_None); resultobj = Py_None;
30900 return resultobj;
30901 fail:
30902 return NULL;
30903 }
30904
30905
30906 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30907 PyObject *resultobj;
30908 size_t result;
30909 char *kwnames[] = {
30910 NULL
30911 };
30912
30913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30914 {
30915 PyThreadState* __tstate = wxPyBeginAllowThreads();
30916 result = (size_t)wxDisplay::GetCount();
30917
30918 wxPyEndAllowThreads(__tstate);
30919 if (PyErr_Occurred()) SWIG_fail;
30920 }
30921 {
30922 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30923 }
30924 return resultobj;
30925 fail:
30926 return NULL;
30927 }
30928
30929
30930 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30931 PyObject *resultobj;
30932 wxPoint *arg1 = 0 ;
30933 int result;
30934 wxPoint temp1 ;
30935 PyObject * obj0 = 0 ;
30936 char *kwnames[] = {
30937 (char *) "pt", NULL
30938 };
30939
30940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30941 {
30942 arg1 = &temp1;
30943 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30944 }
30945 {
30946 PyThreadState* __tstate = wxPyBeginAllowThreads();
30947 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30948
30949 wxPyEndAllowThreads(__tstate);
30950 if (PyErr_Occurred()) SWIG_fail;
30951 }
30952 {
30953 resultobj = SWIG_From_int((int)(result));
30954 }
30955 return resultobj;
30956 fail:
30957 return NULL;
30958 }
30959
30960
30961 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30962 PyObject *resultobj;
30963 wxWindow *arg1 = (wxWindow *) 0 ;
30964 int result;
30965 PyObject * obj0 = 0 ;
30966 char *kwnames[] = {
30967 (char *) "window", NULL
30968 };
30969
30970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30972 if (SWIG_arg_fail(1)) SWIG_fail;
30973 {
30974 PyThreadState* __tstate = wxPyBeginAllowThreads();
30975 result = (int)wxDisplay::GetFromWindow(arg1);
30976
30977 wxPyEndAllowThreads(__tstate);
30978 if (PyErr_Occurred()) SWIG_fail;
30979 }
30980 {
30981 resultobj = SWIG_From_int((int)(result));
30982 }
30983 return resultobj;
30984 fail:
30985 return NULL;
30986 }
30987
30988
30989 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30990 PyObject *resultobj;
30991 wxDisplay *arg1 = (wxDisplay *) 0 ;
30992 bool result;
30993 PyObject * obj0 = 0 ;
30994 char *kwnames[] = {
30995 (char *) "self", NULL
30996 };
30997
30998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31000 if (SWIG_arg_fail(1)) SWIG_fail;
31001 {
31002 PyThreadState* __tstate = wxPyBeginAllowThreads();
31003 result = (bool)((wxDisplay const *)arg1)->IsOk();
31004
31005 wxPyEndAllowThreads(__tstate);
31006 if (PyErr_Occurred()) SWIG_fail;
31007 }
31008 {
31009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31010 }
31011 return resultobj;
31012 fail:
31013 return NULL;
31014 }
31015
31016
31017 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
31018 PyObject *resultobj;
31019 wxDisplay *arg1 = (wxDisplay *) 0 ;
31020 wxRect result;
31021 PyObject * obj0 = 0 ;
31022 char *kwnames[] = {
31023 (char *) "self", NULL
31024 };
31025
31026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
31027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31028 if (SWIG_arg_fail(1)) SWIG_fail;
31029 {
31030 PyThreadState* __tstate = wxPyBeginAllowThreads();
31031 result = ((wxDisplay const *)arg1)->GetGeometry();
31032
31033 wxPyEndAllowThreads(__tstate);
31034 if (PyErr_Occurred()) SWIG_fail;
31035 }
31036 {
31037 wxRect * resultptr;
31038 resultptr = new wxRect((wxRect &)(result));
31039 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
31040 }
31041 return resultobj;
31042 fail:
31043 return NULL;
31044 }
31045
31046
31047 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
31048 PyObject *resultobj;
31049 wxDisplay *arg1 = (wxDisplay *) 0 ;
31050 wxString result;
31051 PyObject * obj0 = 0 ;
31052 char *kwnames[] = {
31053 (char *) "self", NULL
31054 };
31055
31056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
31057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31058 if (SWIG_arg_fail(1)) SWIG_fail;
31059 {
31060 PyThreadState* __tstate = wxPyBeginAllowThreads();
31061 result = ((wxDisplay const *)arg1)->GetName();
31062
31063 wxPyEndAllowThreads(__tstate);
31064 if (PyErr_Occurred()) SWIG_fail;
31065 }
31066 {
31067 #if wxUSE_UNICODE
31068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31069 #else
31070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31071 #endif
31072 }
31073 return resultobj;
31074 fail:
31075 return NULL;
31076 }
31077
31078
31079 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
31080 PyObject *resultobj;
31081 wxDisplay *arg1 = (wxDisplay *) 0 ;
31082 bool result;
31083 PyObject * obj0 = 0 ;
31084 char *kwnames[] = {
31085 (char *) "self", NULL
31086 };
31087
31088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
31089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31090 if (SWIG_arg_fail(1)) SWIG_fail;
31091 {
31092 PyThreadState* __tstate = wxPyBeginAllowThreads();
31093 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31094
31095 wxPyEndAllowThreads(__tstate);
31096 if (PyErr_Occurred()) SWIG_fail;
31097 }
31098 {
31099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31100 }
31101 return resultobj;
31102 fail:
31103 return NULL;
31104 }
31105
31106
31107 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31108 PyObject *resultobj;
31109 wxDisplay *arg1 = (wxDisplay *) 0 ;
31110 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31111 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31112 PyObject *result;
31113 PyObject * obj0 = 0 ;
31114 PyObject * obj1 = 0 ;
31115 char *kwnames[] = {
31116 (char *) "self",(char *) "mode", NULL
31117 };
31118
31119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31121 if (SWIG_arg_fail(1)) SWIG_fail;
31122 if (obj1) {
31123 {
31124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31125 if (SWIG_arg_fail(2)) SWIG_fail;
31126 if (arg2 == NULL) {
31127 SWIG_null_ref("wxVideoMode");
31128 }
31129 if (SWIG_arg_fail(2)) SWIG_fail;
31130 }
31131 }
31132 {
31133 PyThreadState* __tstate = wxPyBeginAllowThreads();
31134 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31135
31136 wxPyEndAllowThreads(__tstate);
31137 if (PyErr_Occurred()) SWIG_fail;
31138 }
31139 resultobj = result;
31140 return resultobj;
31141 fail:
31142 return NULL;
31143 }
31144
31145
31146 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31147 PyObject *resultobj;
31148 wxDisplay *arg1 = (wxDisplay *) 0 ;
31149 wxVideoMode result;
31150 PyObject * obj0 = 0 ;
31151 char *kwnames[] = {
31152 (char *) "self", NULL
31153 };
31154
31155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31157 if (SWIG_arg_fail(1)) SWIG_fail;
31158 {
31159 PyThreadState* __tstate = wxPyBeginAllowThreads();
31160 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31161
31162 wxPyEndAllowThreads(__tstate);
31163 if (PyErr_Occurred()) SWIG_fail;
31164 }
31165 {
31166 wxVideoMode * resultptr;
31167 resultptr = new wxVideoMode((wxVideoMode &)(result));
31168 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31169 }
31170 return resultobj;
31171 fail:
31172 return NULL;
31173 }
31174
31175
31176 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31177 PyObject *resultobj;
31178 wxDisplay *arg1 = (wxDisplay *) 0 ;
31179 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31180 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31181 bool result;
31182 PyObject * obj0 = 0 ;
31183 PyObject * obj1 = 0 ;
31184 char *kwnames[] = {
31185 (char *) "self",(char *) "mode", NULL
31186 };
31187
31188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31190 if (SWIG_arg_fail(1)) SWIG_fail;
31191 if (obj1) {
31192 {
31193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31194 if (SWIG_arg_fail(2)) SWIG_fail;
31195 if (arg2 == NULL) {
31196 SWIG_null_ref("wxVideoMode");
31197 }
31198 if (SWIG_arg_fail(2)) SWIG_fail;
31199 }
31200 }
31201 {
31202 PyThreadState* __tstate = wxPyBeginAllowThreads();
31203 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31204
31205 wxPyEndAllowThreads(__tstate);
31206 if (PyErr_Occurred()) SWIG_fail;
31207 }
31208 {
31209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31210 }
31211 return resultobj;
31212 fail:
31213 return NULL;
31214 }
31215
31216
31217 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31218 PyObject *resultobj;
31219 wxDisplay *arg1 = (wxDisplay *) 0 ;
31220 PyObject * obj0 = 0 ;
31221 char *kwnames[] = {
31222 (char *) "self", NULL
31223 };
31224
31225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31227 if (SWIG_arg_fail(1)) SWIG_fail;
31228 {
31229 PyThreadState* __tstate = wxPyBeginAllowThreads();
31230 (arg1)->ResetMode();
31231
31232 wxPyEndAllowThreads(__tstate);
31233 if (PyErr_Occurred()) SWIG_fail;
31234 }
31235 Py_INCREF(Py_None); resultobj = Py_None;
31236 return resultobj;
31237 fail:
31238 return NULL;
31239 }
31240
31241
31242 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31243 PyObject *obj;
31244 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31245 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31246 Py_INCREF(obj);
31247 return Py_BuildValue((char *)"");
31248 }
31249 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31250 PyObject *resultobj;
31251 wxStandardPaths *result;
31252 char *kwnames[] = {
31253 NULL
31254 };
31255
31256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31257 {
31258 PyThreadState* __tstate = wxPyBeginAllowThreads();
31259 result = (wxStandardPaths *)StandardPaths_Get();
31260
31261 wxPyEndAllowThreads(__tstate);
31262 if (PyErr_Occurred()) SWIG_fail;
31263 }
31264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31265 return resultobj;
31266 fail:
31267 return NULL;
31268 }
31269
31270
31271 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31272 PyObject *resultobj;
31273 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31274 wxString result;
31275 PyObject * obj0 = 0 ;
31276 char *kwnames[] = {
31277 (char *) "self", NULL
31278 };
31279
31280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31282 if (SWIG_arg_fail(1)) SWIG_fail;
31283 {
31284 PyThreadState* __tstate = wxPyBeginAllowThreads();
31285 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31286
31287 wxPyEndAllowThreads(__tstate);
31288 if (PyErr_Occurred()) SWIG_fail;
31289 }
31290 {
31291 #if wxUSE_UNICODE
31292 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31293 #else
31294 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31295 #endif
31296 }
31297 return resultobj;
31298 fail:
31299 return NULL;
31300 }
31301
31302
31303 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31304 PyObject *resultobj;
31305 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31306 wxString result;
31307 PyObject * obj0 = 0 ;
31308 char *kwnames[] = {
31309 (char *) "self", NULL
31310 };
31311
31312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31314 if (SWIG_arg_fail(1)) SWIG_fail;
31315 {
31316 PyThreadState* __tstate = wxPyBeginAllowThreads();
31317 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31318
31319 wxPyEndAllowThreads(__tstate);
31320 if (PyErr_Occurred()) SWIG_fail;
31321 }
31322 {
31323 #if wxUSE_UNICODE
31324 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31325 #else
31326 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31327 #endif
31328 }
31329 return resultobj;
31330 fail:
31331 return NULL;
31332 }
31333
31334
31335 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31336 PyObject *resultobj;
31337 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31338 wxString result;
31339 PyObject * obj0 = 0 ;
31340 char *kwnames[] = {
31341 (char *) "self", NULL
31342 };
31343
31344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31346 if (SWIG_arg_fail(1)) SWIG_fail;
31347 {
31348 PyThreadState* __tstate = wxPyBeginAllowThreads();
31349 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31350
31351 wxPyEndAllowThreads(__tstate);
31352 if (PyErr_Occurred()) SWIG_fail;
31353 }
31354 {
31355 #if wxUSE_UNICODE
31356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31357 #else
31358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31359 #endif
31360 }
31361 return resultobj;
31362 fail:
31363 return NULL;
31364 }
31365
31366
31367 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31368 PyObject *resultobj;
31369 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31370 wxString result;
31371 PyObject * obj0 = 0 ;
31372 char *kwnames[] = {
31373 (char *) "self", NULL
31374 };
31375
31376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31378 if (SWIG_arg_fail(1)) SWIG_fail;
31379 {
31380 PyThreadState* __tstate = wxPyBeginAllowThreads();
31381 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31382
31383 wxPyEndAllowThreads(__tstate);
31384 if (PyErr_Occurred()) SWIG_fail;
31385 }
31386 {
31387 #if wxUSE_UNICODE
31388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31389 #else
31390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31391 #endif
31392 }
31393 return resultobj;
31394 fail:
31395 return NULL;
31396 }
31397
31398
31399 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31400 PyObject *resultobj;
31401 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31402 wxString result;
31403 PyObject * obj0 = 0 ;
31404 char *kwnames[] = {
31405 (char *) "self", NULL
31406 };
31407
31408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31410 if (SWIG_arg_fail(1)) SWIG_fail;
31411 {
31412 PyThreadState* __tstate = wxPyBeginAllowThreads();
31413 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31414
31415 wxPyEndAllowThreads(__tstate);
31416 if (PyErr_Occurred()) SWIG_fail;
31417 }
31418 {
31419 #if wxUSE_UNICODE
31420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31421 #else
31422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31423 #endif
31424 }
31425 return resultobj;
31426 fail:
31427 return NULL;
31428 }
31429
31430
31431 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31432 PyObject *resultobj;
31433 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31434 wxString result;
31435 PyObject * obj0 = 0 ;
31436 char *kwnames[] = {
31437 (char *) "self", NULL
31438 };
31439
31440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31442 if (SWIG_arg_fail(1)) SWIG_fail;
31443 {
31444 PyThreadState* __tstate = wxPyBeginAllowThreads();
31445 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31446
31447 wxPyEndAllowThreads(__tstate);
31448 if (PyErr_Occurred()) SWIG_fail;
31449 }
31450 {
31451 #if wxUSE_UNICODE
31452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31453 #else
31454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31455 #endif
31456 }
31457 return resultobj;
31458 fail:
31459 return NULL;
31460 }
31461
31462
31463 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31464 PyObject *resultobj;
31465 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31466 wxString result;
31467 PyObject * obj0 = 0 ;
31468 char *kwnames[] = {
31469 (char *) "self", NULL
31470 };
31471
31472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31474 if (SWIG_arg_fail(1)) SWIG_fail;
31475 {
31476 PyThreadState* __tstate = wxPyBeginAllowThreads();
31477 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31478
31479 wxPyEndAllowThreads(__tstate);
31480 if (PyErr_Occurred()) SWIG_fail;
31481 }
31482 {
31483 #if wxUSE_UNICODE
31484 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31485 #else
31486 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31487 #endif
31488 }
31489 return resultobj;
31490 fail:
31491 return NULL;
31492 }
31493
31494
31495 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31496 PyObject *resultobj;
31497 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31498 wxString *arg2 = 0 ;
31499 bool temp2 = false ;
31500 PyObject * obj0 = 0 ;
31501 PyObject * obj1 = 0 ;
31502 char *kwnames[] = {
31503 (char *) "self",(char *) "prefix", NULL
31504 };
31505
31506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31508 if (SWIG_arg_fail(1)) SWIG_fail;
31509 {
31510 arg2 = wxString_in_helper(obj1);
31511 if (arg2 == NULL) SWIG_fail;
31512 temp2 = true;
31513 }
31514 {
31515 PyThreadState* __tstate = wxPyBeginAllowThreads();
31516 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31517
31518 wxPyEndAllowThreads(__tstate);
31519 if (PyErr_Occurred()) SWIG_fail;
31520 }
31521 Py_INCREF(Py_None); resultobj = Py_None;
31522 {
31523 if (temp2)
31524 delete arg2;
31525 }
31526 return resultobj;
31527 fail:
31528 {
31529 if (temp2)
31530 delete arg2;
31531 }
31532 return NULL;
31533 }
31534
31535
31536 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31537 PyObject *resultobj;
31538 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31539 wxString result;
31540 PyObject * obj0 = 0 ;
31541 char *kwnames[] = {
31542 (char *) "self", NULL
31543 };
31544
31545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31547 if (SWIG_arg_fail(1)) SWIG_fail;
31548 {
31549 PyThreadState* __tstate = wxPyBeginAllowThreads();
31550 result = wxStandardPaths_GetInstallPrefix(arg1);
31551
31552 wxPyEndAllowThreads(__tstate);
31553 if (PyErr_Occurred()) SWIG_fail;
31554 }
31555 {
31556 #if wxUSE_UNICODE
31557 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31558 #else
31559 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31560 #endif
31561 }
31562 return resultobj;
31563 fail:
31564 return NULL;
31565 }
31566
31567
31568 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31569 PyObject *obj;
31570 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31571 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31572 Py_INCREF(obj);
31573 return Py_BuildValue((char *)"");
31574 }
31575 static PyMethodDef SwigMethods[] = {
31576 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31583 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31591 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31657 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31665 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31683 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31686 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31689 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31692 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31698 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31712 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31718 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31724 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31727 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31741 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31744 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31745 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31748 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31775 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31777 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31779 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31781 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31788 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31794 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31808 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31812 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31815 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31832 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31840 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31887 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31905 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31915 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31931 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31947 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31961 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31971 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
32014 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
32017 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
32020 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
32024 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32117 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32118 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32119 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32120 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32137 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32182 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32216 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32224 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32225 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32230 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32239 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32246 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32249 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32252 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32257 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32260 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32264 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32267 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32271 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32272 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32276 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32277 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32279 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32280 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32281 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32284 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32286 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32290 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32292 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32293 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32294 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32295 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32296 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32297 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32298 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32299 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32300 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32301 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32302 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32303 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32304 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32305 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32306 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32307 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32308 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32309 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32310 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32311 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32312 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32313 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32314 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32315 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32316 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32317 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32318 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32319 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32320 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32321 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32322 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32323 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32324 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32325 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32326 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32327 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32328 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32329 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32330 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32331 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32332 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32333 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32334 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32335 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32336 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32337 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32338 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32339 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32340 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32341 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32342 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32343 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32344 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32345 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32346 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32347 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32348 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32349 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32350 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32351 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32352 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32353 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32354 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32355 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32356 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32357 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32358 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32359 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32360 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32361 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32362 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32363 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32364 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32365 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32366 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32367 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32368 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32369 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32370 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32371 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32372 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32373 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32374 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32375 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32376 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32377 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32378 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32379 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32380 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32381 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32382 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32383 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32384 { NULL, NULL, 0, NULL }
32385 };
32386
32387
32388 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32389
32390 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32391 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32392 }
32393 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32394 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32395 }
32396 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32397 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32398 }
32399 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32400 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32401 }
32402 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32403 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32404 }
32405 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32406 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32407 }
32408 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32409 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32410 }
32411 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32412 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32413 }
32414 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32415 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32416 }
32417 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32418 return (void *)((wxEvent *) ((wxPyEvent *) x));
32419 }
32420 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32421 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32422 }
32423 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32424 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32425 }
32426 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32427 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32428 }
32429 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32430 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32431 }
32432 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32433 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32434 }
32435 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32436 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32437 }
32438 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32439 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32440 }
32441 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32442 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32443 }
32444 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32445 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32446 }
32447 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32448 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32449 }
32450 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32451 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32452 }
32453 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32454 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32455 }
32456 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32457 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32458 }
32459 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32460 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32461 }
32462 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32463 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32464 }
32465 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32466 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32467 }
32468 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32469 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32470 }
32471 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32472 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32473 }
32474 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32475 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32476 }
32477 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32478 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32479 }
32480 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32481 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32482 }
32483 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32484 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32485 }
32486 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32487 return (void *)((wxEvent *) ((wxShowEvent *) x));
32488 }
32489 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32490 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32491 }
32492 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32493 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32494 }
32495 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32496 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32497 }
32498 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32499 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32500 }
32501 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32502 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32503 }
32504 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32505 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32506 }
32507 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32508 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32509 }
32510 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32511 return (void *)((wxConfigBase *) ((wxConfig *) x));
32512 }
32513 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32514 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32515 }
32516 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32517 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32518 }
32519 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32520 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32521 }
32522 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32523 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32524 }
32525 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32526 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32527 }
32528 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32529 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32530 }
32531 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32532 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32533 }
32534 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32535 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32536 }
32537 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32538 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32539 }
32540 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32541 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32542 }
32543 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32544 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32545 }
32546 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32547 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32548 }
32549 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32550 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32551 }
32552 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32553 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32554 }
32555 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32556 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32557 }
32558 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32559 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32560 }
32561 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32562 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32563 }
32564 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32565 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32566 }
32567 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32568 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32569 }
32570 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32571 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32572 }
32573 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32574 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32575 }
32576 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32577 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32578 }
32579 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32580 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32581 }
32582 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32583 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32584 }
32585 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32586 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32587 }
32588 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32589 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32590 }
32591 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32592 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32593 }
32594 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32595 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32596 }
32597 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32598 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32599 }
32600 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32601 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32602 }
32603 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32604 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32605 }
32606 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32607 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32608 }
32609 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32610 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32611 }
32612 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32613 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32614 }
32615 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32616 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32617 }
32618 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32619 return (void *)((wxObject *) ((wxSizerItem *) x));
32620 }
32621 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32622 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32623 }
32624 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32625 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32626 }
32627 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32628 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32629 }
32630 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32631 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32632 }
32633 static void *_p_wxSizerTo_p_wxObject(void *x) {
32634 return (void *)((wxObject *) ((wxSizer *) x));
32635 }
32636 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32637 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32638 }
32639 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32640 return (void *)((wxObject *) ((wxFileHistory *) x));
32641 }
32642 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32643 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32644 }
32645 static void *_p_wxEventTo_p_wxObject(void *x) {
32646 return (void *)((wxObject *) ((wxEvent *) x));
32647 }
32648 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32649 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32650 }
32651 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32652 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32653 }
32654 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32655 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32656 }
32657 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32658 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32659 }
32660 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32661 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32662 }
32663 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32664 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32665 }
32666 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32667 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32668 }
32669 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32670 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32671 }
32672 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32673 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32674 }
32675 static void *_p_wxControlTo_p_wxObject(void *x) {
32676 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32677 }
32678 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32679 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32680 }
32681 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32682 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32683 }
32684 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32685 return (void *)((wxObject *) ((wxFSFile *) x));
32686 }
32687 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32688 return (void *)((wxObject *) ((wxClipboard *) x));
32689 }
32690 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32691 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32692 }
32693 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32694 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32695 }
32696 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32697 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32698 }
32699 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32700 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32701 }
32702 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32703 return (void *)((wxObject *) ((wxToolTip *) x));
32704 }
32705 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32706 return (void *)((wxObject *) ((wxMenuItem *) x));
32707 }
32708 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32709 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32710 }
32711 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32712 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32713 }
32714 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32715 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32716 }
32717 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32718 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32719 }
32720 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32721 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32722 }
32723 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32724 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32725 }
32726 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32727 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32728 }
32729 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32730 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32731 }
32732 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32733 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32734 }
32735 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32736 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32737 }
32738 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32739 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32740 }
32741 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32742 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32743 }
32744 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32745 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32746 }
32747 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32748 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32749 }
32750 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32751 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32752 }
32753 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32754 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32755 }
32756 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32757 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32758 }
32759 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32760 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32761 }
32762 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32763 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32764 }
32765 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32766 return (void *)((wxObject *) ((wxImageHandler *) x));
32767 }
32768 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32769 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32770 }
32771 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32772 return (void *)((wxObject *) ((wxEvtHandler *) x));
32773 }
32774 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32775 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32776 }
32777 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32778 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32779 }
32780 static void *_p_wxImageTo_p_wxObject(void *x) {
32781 return (void *)((wxObject *) ((wxImage *) x));
32782 }
32783 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32784 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32785 }
32786 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32787 return (void *)((wxObject *) ((wxSystemOptions *) x));
32788 }
32789 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32790 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32791 }
32792 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32793 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32794 }
32795 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32796 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32797 }
32798 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32799 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32800 }
32801 static void *_p_wxWindowTo_p_wxObject(void *x) {
32802 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32803 }
32804 static void *_p_wxMenuTo_p_wxObject(void *x) {
32805 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32806 }
32807 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32808 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32809 }
32810 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32811 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32812 }
32813 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32814 return (void *)((wxObject *) ((wxFileSystem *) x));
32815 }
32816 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32817 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32818 }
32819 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32820 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32821 }
32822 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32823 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32824 }
32825 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32826 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32827 }
32828 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32829 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32830 }
32831 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32832 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32833 }
32834 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32835 return (void *)((wxObject *) ((wxBusyInfo *) x));
32836 }
32837 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32838 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32839 }
32840 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32841 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32842 }
32843 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32844 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32845 }
32846 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32847 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32848 }
32849 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32850 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32851 }
32852 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32853 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32854 }
32855 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32856 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32857 }
32858 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32859 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32860 }
32861 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32862 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32863 }
32864 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32865 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32866 }
32867 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32868 return (void *)((wxLog *) ((wxLogStderr *) x));
32869 }
32870 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32871 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32872 }
32873 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32874 return (void *)((wxLog *) ((wxLogWindow *) x));
32875 }
32876 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32877 return (void *)((wxLog *) ((wxLogChain *) x));
32878 }
32879 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32880 return (void *)((wxLog *) ((wxLogGui *) x));
32881 }
32882 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32883 return (void *)((wxLog *) ((wxPyLog *) x));
32884 }
32885 static void *_p_wxControlTo_p_wxWindow(void *x) {
32886 return (void *)((wxWindow *) ((wxControl *) x));
32887 }
32888 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32889 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32890 }
32891 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32892 return (void *)((wxWindow *) ((wxMenuBar *) x));
32893 }
32894 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32895 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32896 }
32897 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32898 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32899 }
32900 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}};
32901 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}};
32902 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}};
32903 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}};
32904 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}};
32905 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}};
32906 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}};
32907 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}};
32908 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}};
32909 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}};
32910 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}};
32911 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}};
32912 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}};
32913 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}};
32914 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}};
32915 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}};
32916 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}};
32917 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}};
32918 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}};
32919 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}};
32920 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}};
32921 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}};
32922 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}};
32923 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}};
32924 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}};
32925 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}};
32926 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}};
32927 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}};
32928 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}};
32929 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}};
32930 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}};
32931 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}};
32932 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}};
32933 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}};
32934 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}};
32935 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}};
32936 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}};
32937 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}};
32938 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}};
32939 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}};
32940 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}};
32941 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}};
32942 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}};
32943 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}};
32944 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}};
32945 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}};
32946 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}};
32947 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}};
32948 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}};
32949 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}};
32950 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}};
32951 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}};
32952 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}};
32953 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}};
32954 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}};
32955 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}};
32956 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}};
32957 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}};
32958 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}};
32959 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}};
32960 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}};
32961 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}};
32962 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}};
32963 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}};
32964 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}};
32965 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}};
32966 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}};
32967 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}};
32968 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}};
32969 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}};
32970 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}};
32971 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}};
32972 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}};
32973 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}};
32974 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}};
32975 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}};
32976 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}};
32977 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}};
32978 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}};
32979 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}};
32980 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}};
32981 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}};
32982 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}};
32983 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}};
32984 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}};
32985 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}};
32986 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}};
32987 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}};
32988 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}};
32989 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}};
32990 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}};
32991 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}};
32992 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}};
32993 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}};
32994 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}};
32995 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}};
32996 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}};
32997 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}};
32998
32999 static swig_type_info *swig_types_initial[] = {
33000 _swigt__p_wxLogChain,
33001 _swigt__p_wxMutexGuiLocker,
33002 _swigt__p_wxMetafile,
33003 _swigt__p_wxFileHistory,
33004 _swigt__p_wxLog,
33005 _swigt__p_wxMenu,
33006 _swigt__p_wxEvent,
33007 _swigt__p_wxDateTime__TimeZone,
33008 _swigt__p_wxConfigBase,
33009 _swigt__p_wxDisplay,
33010 _swigt__p_wxFileType,
33011 _swigt__p_wxLogGui,
33012 _swigt__p_wxFont,
33013 _swigt__p_wxDataFormat,
33014 _swigt__p_wxTimerEvent,
33015 _swigt__p_wxCaret,
33016 _swigt__ptrdiff_t,
33017 _swigt__std__ptrdiff_t,
33018 _swigt__p_void,
33019 _swigt__p_int,
33020 _swigt__p_wxSize,
33021 _swigt__p_wxClipboard,
33022 _swigt__p_wxStopWatch,
33023 _swigt__p_wxDC,
33024 _swigt__p_wxClipboardLocker,
33025 _swigt__p_wxIcon,
33026 _swigt__p_wxLogStderr,
33027 _swigt__p_wxLogTextCtrl,
33028 _swigt__p_wxTextCtrl,
33029 _swigt__p_wxBusyCursor,
33030 _swigt__p_wxBitmapDataObject,
33031 _swigt__p_wxTextDataObject,
33032 _swigt__p_wxDataObject,
33033 _swigt__p_wxPyTextDataObject,
33034 _swigt__p_wxPyBitmapDataObject,
33035 _swigt__p_wxFileDataObject,
33036 _swigt__p_wxCustomDataObject,
33037 _swigt__p_wxURLDataObject,
33038 _swigt__p_wxMetafileDataObject,
33039 _swigt__p_wxSound,
33040 _swigt__p_wxTimerRunner,
33041 _swigt__p_wxLogWindow,
33042 _swigt__p_wxTimeSpan,
33043 _swigt__p_wxArrayString,
33044 _swigt__p_wxWindowDisabler,
33045 _swigt__p_form_ops_t,
33046 _swigt__p_wxToolTip,
33047 _swigt__p_wxDataObjectComposite,
33048 _swigt__p_wxSystemSettings,
33049 _swigt__p_wxFileConfig,
33050 _swigt__p_wxVideoMode,
33051 _swigt__p_wxDataObjectSimple,
33052 _swigt__p_wxPyDataObjectSimple,
33053 _swigt__p_wxDuplexMode,
33054 _swigt__p_wxEvtHandler,
33055 _swigt__p_wxRect,
33056 _swigt__p_char,
33057 _swigt__p_wxSingleInstanceChecker,
33058 _swigt__p_wxStandardPaths,
33059 _swigt__p_wxFileTypeInfo,
33060 _swigt__p_wxFrame,
33061 _swigt__p_wxTimer,
33062 _swigt__p_wxPaperSize,
33063 _swigt__p_wxMimeTypesManager,
33064 _swigt__p_wxPyArtProvider,
33065 _swigt__p_wxPyTipProvider,
33066 _swigt__p_wxTipProvider,
33067 _swigt__p_wxJoystick,
33068 _swigt__p_wxSystemOptions,
33069 _swigt__p_wxPoint,
33070 _swigt__p_wxJoystickEvent,
33071 _swigt__p_wxCursor,
33072 _swigt__p_wxObject,
33073 _swigt__p_wxOutputStream,
33074 _swigt__p_wxDateTime,
33075 _swigt__p_wxPyDropSource,
33076 _swigt__p_unsigned_long,
33077 _swigt__p_wxKillError,
33078 _swigt__p_wxWindow,
33079 _swigt__p_wxString,
33080 _swigt__p_wxPyProcess,
33081 _swigt__p_wxBitmap,
33082 _swigt__unsigned_int,
33083 _swigt__p_unsigned_int,
33084 _swigt__p_wxConfig,
33085 _swigt__p_unsigned_char,
33086 _swigt__p_wxChar,
33087 _swigt__p_wxBusyInfo,
33088 _swigt__p_wxPyDropTarget,
33089 _swigt__p_wxPyTextDropTarget,
33090 _swigt__p_wxPyFileDropTarget,
33091 _swigt__p_wxProcessEvent,
33092 _swigt__p_wxPyLog,
33093 _swigt__p_wxLogNull,
33094 _swigt__p_wxColour,
33095 _swigt__p_wxPyTimer,
33096 _swigt__p_wxConfigPathChanger,
33097 _swigt__p_wxDateSpan,
33098 0
33099 };
33100
33101
33102 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33103
33104 static swig_const_info swig_const_table[] = {
33105 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33106 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33107 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33108 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33109 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33110 {0, 0, 0, 0.0, 0, 0}};
33111
33112 #ifdef __cplusplus
33113 }
33114 #endif
33115
33116
33117 #ifdef __cplusplus
33118 extern "C" {
33119 #endif
33120
33121 /* Python-specific SWIG API */
33122 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33123 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33124 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33125
33126 /* -----------------------------------------------------------------------------
33127 * global variable support code.
33128 * ----------------------------------------------------------------------------- */
33129
33130 typedef struct swig_globalvar {
33131 char *name; /* Name of global variable */
33132 PyObject *(*get_attr)(); /* Return the current value */
33133 int (*set_attr)(PyObject *); /* Set the value */
33134 struct swig_globalvar *next;
33135 } swig_globalvar;
33136
33137 typedef struct swig_varlinkobject {
33138 PyObject_HEAD
33139 swig_globalvar *vars;
33140 } swig_varlinkobject;
33141
33142 static PyObject *
33143 swig_varlink_repr(swig_varlinkobject *v) {
33144 v = v;
33145 return PyString_FromString("<Swig global variables>");
33146 }
33147
33148 static int
33149 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33150 swig_globalvar *var;
33151 flags = flags;
33152 fprintf(fp,"Swig global variables { ");
33153 for (var = v->vars; var; var=var->next) {
33154 fprintf(fp,"%s", var->name);
33155 if (var->next) fprintf(fp,", ");
33156 }
33157 fprintf(fp," }\n");
33158 return 0;
33159 }
33160
33161 static PyObject *
33162 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33163 swig_globalvar *var = v->vars;
33164 while (var) {
33165 if (strcmp(var->name,n) == 0) {
33166 return (*var->get_attr)();
33167 }
33168 var = var->next;
33169 }
33170 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33171 return NULL;
33172 }
33173
33174 static int
33175 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33176 swig_globalvar *var = v->vars;
33177 while (var) {
33178 if (strcmp(var->name,n) == 0) {
33179 return (*var->set_attr)(p);
33180 }
33181 var = var->next;
33182 }
33183 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33184 return 1;
33185 }
33186
33187 static PyTypeObject varlinktype = {
33188 PyObject_HEAD_INIT(0)
33189 0, /* Number of items in variable part (ob_size) */
33190 (char *)"swigvarlink", /* Type name (tp_name) */
33191 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33192 0, /* Itemsize (tp_itemsize) */
33193 0, /* Deallocator (tp_dealloc) */
33194 (printfunc) swig_varlink_print, /* Print (tp_print) */
33195 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33196 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33197 0, /* tp_compare */
33198 (reprfunc) swig_varlink_repr, /* tp_repr */
33199 0, /* tp_as_number */
33200 0, /* tp_as_sequence */
33201 0, /* tp_as_mapping */
33202 0, /* tp_hash */
33203 0, /* tp_call */
33204 0, /* tp_str */
33205 0, /* tp_getattro */
33206 0, /* tp_setattro */
33207 0, /* tp_as_buffer */
33208 0, /* tp_flags */
33209 0, /* tp_doc */
33210 #if PY_VERSION_HEX >= 0x02000000
33211 0, /* tp_traverse */
33212 0, /* tp_clear */
33213 #endif
33214 #if PY_VERSION_HEX >= 0x02010000
33215 0, /* tp_richcompare */
33216 0, /* tp_weaklistoffset */
33217 #endif
33218 #if PY_VERSION_HEX >= 0x02020000
33219 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33220 #endif
33221 #if PY_VERSION_HEX >= 0x02030000
33222 0, /* tp_del */
33223 #endif
33224 #ifdef COUNT_ALLOCS
33225 0,0,0,0 /* tp_alloc -> tp_next */
33226 #endif
33227 };
33228
33229 /* Create a variable linking object for use later */
33230 static PyObject *
33231 SWIG_Python_newvarlink(void) {
33232 swig_varlinkobject *result = 0;
33233 result = PyMem_NEW(swig_varlinkobject,1);
33234 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33235 result->ob_type = &varlinktype;
33236 result->vars = 0;
33237 result->ob_refcnt = 0;
33238 Py_XINCREF((PyObject *) result);
33239 return ((PyObject*) result);
33240 }
33241
33242 static void
33243 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33244 swig_varlinkobject *v;
33245 swig_globalvar *gv;
33246 v= (swig_varlinkobject *) p;
33247 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33248 gv->name = (char *) malloc(strlen(name)+1);
33249 strcpy(gv->name,name);
33250 gv->get_attr = get_attr;
33251 gv->set_attr = set_attr;
33252 gv->next = v->vars;
33253 v->vars = gv;
33254 }
33255
33256 /* -----------------------------------------------------------------------------
33257 * constants/methods manipulation
33258 * ----------------------------------------------------------------------------- */
33259
33260 /* Install Constants */
33261 static void
33262 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33263 PyObject *obj = 0;
33264 size_t i;
33265 for (i = 0; constants[i].type; i++) {
33266 switch(constants[i].type) {
33267 case SWIG_PY_INT:
33268 obj = PyInt_FromLong(constants[i].lvalue);
33269 break;
33270 case SWIG_PY_FLOAT:
33271 obj = PyFloat_FromDouble(constants[i].dvalue);
33272 break;
33273 case SWIG_PY_STRING:
33274 if (constants[i].pvalue) {
33275 obj = PyString_FromString((char *) constants[i].pvalue);
33276 } else {
33277 Py_INCREF(Py_None);
33278 obj = Py_None;
33279 }
33280 break;
33281 case SWIG_PY_POINTER:
33282 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33283 break;
33284 case SWIG_PY_BINARY:
33285 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33286 break;
33287 default:
33288 obj = 0;
33289 break;
33290 }
33291 if (obj) {
33292 PyDict_SetItemString(d,constants[i].name,obj);
33293 Py_DECREF(obj);
33294 }
33295 }
33296 }
33297
33298 /* -----------------------------------------------------------------------------*/
33299 /* Fix SwigMethods to carry the callback ptrs when needed */
33300 /* -----------------------------------------------------------------------------*/
33301
33302 static void
33303 SWIG_Python_FixMethods(PyMethodDef *methods,
33304 swig_const_info *const_table,
33305 swig_type_info **types,
33306 swig_type_info **types_initial) {
33307 size_t i;
33308 for (i = 0; methods[i].ml_name; ++i) {
33309 char *c = methods[i].ml_doc;
33310 if (c && (c = strstr(c, "swig_ptr: "))) {
33311 int j;
33312 swig_const_info *ci = 0;
33313 char *name = c + 10;
33314 for (j = 0; const_table[j].type; j++) {
33315 if (strncmp(const_table[j].name, name,
33316 strlen(const_table[j].name)) == 0) {
33317 ci = &(const_table[j]);
33318 break;
33319 }
33320 }
33321 if (ci) {
33322 size_t shift = (ci->ptype) - types;
33323 swig_type_info *ty = types_initial[shift];
33324 size_t ldoc = (c - methods[i].ml_doc);
33325 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33326 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33327 char *buff = ndoc;
33328 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33329 strncpy(buff, methods[i].ml_doc, ldoc);
33330 buff += ldoc;
33331 strncpy(buff, "swig_ptr: ", 10);
33332 buff += 10;
33333 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33334 methods[i].ml_doc = ndoc;
33335 }
33336 }
33337 }
33338 }
33339
33340 /* -----------------------------------------------------------------------------*
33341 * Initialize type list
33342 * -----------------------------------------------------------------------------*/
33343
33344 #if PY_MAJOR_VERSION < 2
33345 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33346 is copied out of Python/modsupport.c in python version 2.3.4 */
33347 static int
33348 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33349 {
33350 PyObject *dict;
33351 if (!PyModule_Check(m)) {
33352 PyErr_SetString(PyExc_TypeError,
33353 "PyModule_AddObject() needs module as first arg");
33354 return -1;
33355 }
33356 if (!o) {
33357 PyErr_SetString(PyExc_TypeError,
33358 "PyModule_AddObject() needs non-NULL value");
33359 return -1;
33360 }
33361
33362 dict = PyModule_GetDict(m);
33363 if (dict == NULL) {
33364 /* Internal error -- modules must have a dict! */
33365 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33366 PyModule_GetName(m));
33367 return -1;
33368 }
33369 if (PyDict_SetItemString(dict, name, o))
33370 return -1;
33371 Py_DECREF(o);
33372 return 0;
33373 }
33374 #endif
33375
33376 static swig_type_info **
33377 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33378 static PyMethodDef swig_empty_runtime_method_table[] = {
33379 {
33380 NULL, NULL, 0, NULL
33381 }
33382 };/* Sentinel */
33383
33384 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33385 swig_empty_runtime_method_table);
33386 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33387 if (pointer && module) {
33388 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33389 }
33390 return type_list_handle;
33391 }
33392
33393 static swig_type_info **
33394 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33395 swig_type_info **type_pointer;
33396
33397 /* first check if module already created */
33398 type_pointer = SWIG_Python_GetTypeListHandle();
33399 if (type_pointer) {
33400 return type_pointer;
33401 } else {
33402 /* create a new module and variable */
33403 return SWIG_Python_SetTypeListHandle(type_list_handle);
33404 }
33405 }
33406
33407 #ifdef __cplusplus
33408 }
33409 #endif
33410
33411 /* -----------------------------------------------------------------------------*
33412 * Partial Init method
33413 * -----------------------------------------------------------------------------*/
33414
33415 #ifdef SWIG_LINK_RUNTIME
33416 #ifdef __cplusplus
33417 extern "C"
33418 #endif
33419 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33420 #endif
33421
33422 #ifdef __cplusplus
33423 extern "C"
33424 #endif
33425 SWIGEXPORT(void) SWIG_init(void) {
33426 static PyObject *SWIG_globals = 0;
33427 static int typeinit = 0;
33428 PyObject *m, *d;
33429 int i;
33430 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33431
33432 /* Fix SwigMethods to carry the callback ptrs when needed */
33433 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33434
33435 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33436 d = PyModule_GetDict(m);
33437
33438 if (!typeinit) {
33439 #ifdef SWIG_LINK_RUNTIME
33440 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33441 #else
33442 # ifndef SWIG_STATIC_RUNTIME
33443 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33444 # endif
33445 #endif
33446 for (i = 0; swig_types_initial[i]; i++) {
33447 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33448 }
33449 typeinit = 1;
33450 }
33451 SWIG_InstallConstants(d,swig_const_table);
33452
33453 {
33454 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33455 }
33456 {
33457 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33458 }
33459 {
33460 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33461 }
33462 {
33463 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33464 }
33465 {
33466 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33467 }
33468 {
33469 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33470 }
33471 {
33472 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33473 }
33474 {
33475 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33476 }
33477 {
33478 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33479 }
33480 {
33481 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33482 }
33483 {
33484 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33485 }
33486 {
33487 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33488 }
33489 {
33490 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33491 }
33492 {
33493 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33515 }
33516 {
33517 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33524 }
33525 {
33526 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33527 }
33528 {
33529 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33530 }
33531 {
33532 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33533 }
33534 {
33535 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33539 }
33540 {
33541 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33542 }
33543 {
33544 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33545 }
33546 {
33547 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33548 }
33549 {
33550 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33551 }
33552 {
33553 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33569 }
33570 {
33571 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33584 }
33585 {
33586 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33587 }
33588 {
33589 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33590 }
33591 {
33592 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33593 }
33594 {
33595 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33596 }
33597 {
33598 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33599 }
33600 {
33601 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33602 }
33603 {
33604 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33605 }
33606 {
33607 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33608 }
33609 {
33610 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33623 }
33624 {
33625 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33626 }
33627 {
33628 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33629 }
33630 {
33631 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33632 }
33633 {
33634 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33644 }
33645 {
33646 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33647 }
33648 {
33649 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33650 }
33651 {
33652 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33665 }
33666 {
33667 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33668 }
33669 {
33670 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33671 }
33672 {
33673 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33674 }
33675 {
33676 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33677 }
33678 {
33679 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33683 }
33684 {
33685 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33686 }
33687 {
33688 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33689 }
33690 {
33691 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33692 }
33693 {
33694 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33695 }
33696 {
33697 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33698 }
33699 {
33700 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33701 }
33702 {
33703 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33704 }
33705 {
33706 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33707 }
33708 {
33709 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33710 }
33711 {
33712 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33713 }
33714 {
33715 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33716 }
33717 {
33718 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33719 }
33720 {
33721 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33722 }
33723 {
33724 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33725 }
33726 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33727 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33728 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33729 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33730 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33731 {
33732 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33742 }
33743 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33744
33745 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33746
33747 {
33748 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33749 }
33750 {
33751 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33752 }
33753 {
33754 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33755 }
33756 {
33757 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33758 }
33759 {
33760 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33761 }
33762 {
33763 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33764 }
33765 {
33766 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33767 }
33768 {
33769 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33770 }
33771 {
33772 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33773 }
33774 {
33775 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33776 }
33777 {
33778 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33779 }
33780 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33781 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33782 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33783 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33784 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33785 {
33786 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33799 }
33800 {
33801 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33802 }
33803 {
33804 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33805 }
33806 {
33807 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33808 }
33809 {
33810 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33811 }
33812 {
33813 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33814 }
33815 {
33816 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33817 }
33818 {
33819 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33820 }
33821 {
33822 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33823 }
33824 {
33825 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33826 }
33827 {
33828 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33829 }
33830 {
33831 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33832 }
33833 {
33834 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33835 }
33836 {
33837 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33838 }
33839 {
33840 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33841 }
33842 {
33843 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33844 }
33845 {
33846 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33847 }
33848 {
33849 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33850 }
33851 {
33852 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33853 }
33854 {
33855 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33856 }
33857 {
33858 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33859 }
33860 {
33861 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33862 }
33863 {
33864 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33865 }
33866 {
33867 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33868 }
33869 {
33870 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33871 }
33872 {
33873 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33874 }
33875 {
33876 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33877 }
33878 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33879 {
33880 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33881 }
33882 {
33883 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33887 }
33888 {
33889 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33890 }
33891 {
33892 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33893 }
33894
33895 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33896
33897 {
33898 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33899 }
33900 {
33901 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33902 }
33903 {
33904 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33905 }
33906 {
33907 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33908 }
33909 {
33910 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33911 }
33912 {
33913 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33914 }
33915 {
33916 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33917 }
33918 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33919 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33920 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33921 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33922 {
33923 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33924 }
33925 {
33926 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33927 }
33928 {
33929 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33930 }
33931 {
33932 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33933 }
33934 {
33935 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33936 }
33937 {
33938 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33939 }
33940 {
33941 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33942 }
33943 {
33944 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33945 }
33946 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33947 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33948 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33949 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33950 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33951 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33952 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33953 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33954 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33955 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33956 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33957 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33958 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33959 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33960 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33961 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33962 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33963 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33964 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33965 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33966 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33967 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33968 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33969 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33970 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33971 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33972 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33973 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33974 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33975 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33976 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33977 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33978 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33979 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33980 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33981 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33982 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33983 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33984 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33985 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33986 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33987 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33988 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33989 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33990 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33991 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33992 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33993 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33994 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33995 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33996 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33997 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW",_wrap_ART_NEW_get, _wrap_ART_NEW_set);
33998 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33999 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
34000 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
34001 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
34002 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
34003
34004 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
34005
34006 {
34007 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
34008 }
34009 {
34010 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
34011 }
34012 {
34013 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
34014 }
34015 {
34016 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
34017 }
34018 {
34019 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
34020 }
34021 {
34022 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
34023 }
34024 {
34025 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
34026 }
34027 {
34028 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
34029 }
34030 {
34031 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
34032 }
34033 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
34034 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
34035 {
34036 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
34037 }
34038 {
34039 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
34040 }
34041 {
34042 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
34043 }
34044 {
34045 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
34046 }
34047 {
34048 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
34049 }
34050 {
34051 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
34052 }
34053 {
34054 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
34055 }
34056 {
34057 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
34058 }
34059 {
34060 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
34061 }
34062 {
34063 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
34064 }
34065 {
34066 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
34067 }
34068 {
34069 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
34070 }
34071 {
34072 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
34073 }
34074 {
34075 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
34076 }
34077 {
34078 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
34079 }
34080 {
34081 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
34082 }
34083 {
34084 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
34085 }
34086 {
34087 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
34088 }
34089 {
34090 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
34091 }
34092 {
34093 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
34094 }
34095 {
34096 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34097 }
34098 {
34099 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34100 }
34101 {
34102 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34103 }
34104 {
34105 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34106 }
34107 {
34108 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34109 }
34110 {
34111 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34112 }
34113 {
34114 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34115 }
34116 {
34117 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34118 }
34119 {
34120 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34121 }
34122 {
34123 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34124 }
34125 {
34126 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34127 }
34128 {
34129 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34130 }
34131 {
34132 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34133 }
34134 {
34135 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34136 }
34137 {
34138 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34139 }
34140 {
34141 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34142 }
34143 {
34144 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34145 }
34146 {
34147 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34148 }
34149 {
34150 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34151 }
34152 {
34153 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34154 }
34155 {
34156 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34157 }
34158 {
34159 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34160 }
34161 {
34162 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34163 }
34164 {
34165 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34166 }
34167 {
34168 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34169 }
34170 {
34171 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34172 }
34173 {
34174 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34175 }
34176 {
34177 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34178 }
34179 {
34180 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34181 }
34182 {
34183 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34184 }
34185 {
34186 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34187 }
34188 {
34189 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34190 }
34191 {
34192 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34193 }
34194 {
34195 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34196 }
34197 {
34198 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34199 }
34200 {
34201 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34202 }
34203 {
34204 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34205 }
34206 {
34207 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34208 }
34209 {
34210 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34211 }
34212 {
34213 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34214 }
34215 {
34216 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34217 }
34218 {
34219 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34220 }
34221 {
34222 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34223 }
34224 {
34225 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34226 }
34227 {
34228 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34229 }
34230 {
34231 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34232 }
34233 {
34234 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34235 }
34236 {
34237 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34238 }
34239 {
34240 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34241 }
34242 {
34243 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34244 }
34245 {
34246 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34247 }
34248 {
34249 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34250 }
34251 {
34252 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34253 }
34254 {
34255 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34256 }
34257 {
34258 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34259 }
34260 {
34261 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34262 }
34263 {
34264 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34265 }
34266 {
34267 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34268 }
34269 {
34270 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34271 }
34272 {
34273 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34274 }
34275 {
34276 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34277 }
34278 {
34279 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34280 }
34281 {
34282 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34283 }
34284 {
34285 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34286 }
34287 {
34288 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34289 }
34290 {
34291 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34292 }
34293 {
34294 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34295 }
34296 {
34297 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34298 }
34299 {
34300 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34301 }
34302 {
34303 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34304 }
34305 {
34306 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34307 }
34308 {
34309 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34310 }
34311 {
34312 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34313 }
34314 {
34315 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34316 }
34317 {
34318 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34319 }
34320 {
34321 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34322 }
34323 {
34324 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34325 }
34326 {
34327 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34328 }
34329 {
34330 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34331 }
34332 {
34333 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34334 }
34335 {
34336 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34337 }
34338 {
34339 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34340 }
34341 {
34342 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34343 }
34344 {
34345 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34346 }
34347 {
34348 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34349 }
34350 {
34351 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34352 }
34353 {
34354 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34355 }
34356 {
34357 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34358 }
34359 {
34360 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34361 }
34362 {
34363 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34364 }
34365 {
34366 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34367 }
34368 {
34369 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34370 }
34371 {
34372 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34373 }
34374 {
34375 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34376 }
34377 {
34378 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34379 }
34380 {
34381 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34382 }
34383 {
34384 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34385 }
34386 {
34387 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34388 }
34389 {
34390 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34391 }
34392 {
34393 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34394 }
34395 {
34396 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34397 }
34398 {
34399 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34400 }
34401 {
34402 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34403 }
34404 {
34405 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34406 }
34407 {
34408 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34409 }
34410 {
34411 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34412 }
34413 {
34414 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34415 }
34416 {
34417 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34418 }
34419 {
34420 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34421 }
34422 {
34423 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34424 }
34425 {
34426 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34427 }
34428 {
34429 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34430 }
34431 {
34432 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34433 }
34434 {
34435 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34436 }
34437 {
34438 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34439 }
34440 {
34441 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34442 }
34443 {
34444 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34445 }
34446 {
34447 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34448 }
34449 {
34450 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34451 }
34452 {
34453 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34454 }
34455 {
34456 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34457 }
34458 {
34459 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34460 }
34461 {
34462 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34463 }
34464 {
34465 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34466 }
34467 {
34468 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34469 }
34470 {
34471 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34472 }
34473 {
34474 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34475 }
34476 {
34477 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34478 }
34479 {
34480 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34481 }
34482 {
34483 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34484 }
34485 {
34486 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34487 }
34488 {
34489 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34490 }
34491 {
34492 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34493 }
34494 {
34495 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34496 }
34497 {
34498 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34499 }
34500 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34501 {
34502 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34503 }
34504 {
34505 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34506 }
34507 {
34508 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34509 }
34510 {
34511 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34512 }
34513 {
34514 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34515 }
34516 {
34517 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34518 }
34519 {
34520 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34521 }
34522 {
34523 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34524 }
34525 {
34526 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34527 }
34528 {
34529 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34530 }
34531 {
34532 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34533 }
34534 {
34535 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34536 }
34537 {
34538 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34539 }
34540 {
34541 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34542 }
34543 {
34544 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34545 }
34546 {
34547 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34548 }
34549 {
34550 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34551 }
34552 {
34553 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34554 }
34555 {
34556 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34557 }
34558 {
34559 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34560 }
34561 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34562 {
34563 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34564 }
34565 {
34566 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34567 }
34568 {
34569 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34570 }
34571 {
34572 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34573 }
34574 {
34575 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34576 }
34577 {
34578 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34579 }
34580 {
34581 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34582 }
34583 {
34584 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34585 }
34586 {
34587 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34588 }
34589 {
34590 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34591 }
34592 {
34593 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34594 }
34595 {
34596 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34597 }
34598
34599 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34600 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34601 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34602 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34603
34604 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34605 }
34606
wxWidgets (Impactor)