]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
re-enable wxDrawWindowOnDC
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxFileHistory swig_types[2]
1344 #define SWIGTYPE_p_wxLog swig_types[3]
1345 #define SWIGTYPE_p_wxMenu swig_types[4]
1346 #define SWIGTYPE_p_wxEvent swig_types[5]
1347 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[6]
1348 #define SWIGTYPE_p_wxConfigBase swig_types[7]
1349 #define SWIGTYPE_p_wxDisplay swig_types[8]
1350 #define SWIGTYPE_p_wxFileType swig_types[9]
1351 #define SWIGTYPE_p_wxLogGui swig_types[10]
1352 #define SWIGTYPE_p_wxFont swig_types[11]
1353 #define SWIGTYPE_p_wxDataFormat swig_types[12]
1354 #define SWIGTYPE_p_wxTimerEvent swig_types[13]
1355 #define SWIGTYPE_p_wxCaret swig_types[14]
1356 #define SWIGTYPE_ptrdiff_t swig_types[15]
1357 #define SWIGTYPE_std__ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_p_int swig_types[17]
1359 #define SWIGTYPE_p_wxSize swig_types[18]
1360 #define SWIGTYPE_p_wxClipboard swig_types[19]
1361 #define SWIGTYPE_p_wxStopWatch swig_types[20]
1362 #define SWIGTYPE_p_wxClipboardLocker swig_types[21]
1363 #define SWIGTYPE_p_wxIcon swig_types[22]
1364 #define SWIGTYPE_p_wxLogStderr swig_types[23]
1365 #define SWIGTYPE_p_wxLogTextCtrl swig_types[24]
1366 #define SWIGTYPE_p_wxTextCtrl swig_types[25]
1367 #define SWIGTYPE_p_wxBusyCursor swig_types[26]
1368 #define SWIGTYPE_p_wxBitmapDataObject swig_types[27]
1369 #define SWIGTYPE_p_wxTextDataObject swig_types[28]
1370 #define SWIGTYPE_p_wxDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxPyTextDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxFileDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxCustomDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxURLDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxMetafileDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxSound swig_types[36]
1378 #define SWIGTYPE_p_wxTimerRunner swig_types[37]
1379 #define SWIGTYPE_p_wxLogWindow swig_types[38]
1380 #define SWIGTYPE_p_wxTimeSpan swig_types[39]
1381 #define SWIGTYPE_p_wxArrayString swig_types[40]
1382 #define SWIGTYPE_p_wxWindowDisabler swig_types[41]
1383 #define SWIGTYPE_p_form_ops_t swig_types[42]
1384 #define SWIGTYPE_p_wxToolTip swig_types[43]
1385 #define SWIGTYPE_p_wxDataObjectComposite swig_types[44]
1386 #define SWIGTYPE_p_wxFileConfig swig_types[45]
1387 #define SWIGTYPE_p_wxSystemSettings swig_types[46]
1388 #define SWIGTYPE_p_wxVideoMode swig_types[47]
1389 #define SWIGTYPE_p_wxDataObjectSimple swig_types[48]
1390 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[49]
1391 #define SWIGTYPE_p_wxDuplexMode swig_types[50]
1392 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
1393 #define SWIGTYPE_p_wxRect swig_types[52]
1394 #define SWIGTYPE_p_char swig_types[53]
1395 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[54]
1396 #define SWIGTYPE_p_wxStandardPaths swig_types[55]
1397 #define SWIGTYPE_p_wxFileTypeInfo swig_types[56]
1398 #define SWIGTYPE_p_wxFrame swig_types[57]
1399 #define SWIGTYPE_p_wxTimer swig_types[58]
1400 #define SWIGTYPE_p_wxPaperSize swig_types[59]
1401 #define SWIGTYPE_p_wxMimeTypesManager swig_types[60]
1402 #define SWIGTYPE_p_wxPyArtProvider swig_types[61]
1403 #define SWIGTYPE_p_wxPyTipProvider swig_types[62]
1404 #define SWIGTYPE_p_wxTipProvider swig_types[63]
1405 #define SWIGTYPE_p_wxJoystick swig_types[64]
1406 #define SWIGTYPE_p_wxSystemOptions swig_types[65]
1407 #define SWIGTYPE_p_wxPoint swig_types[66]
1408 #define SWIGTYPE_p_wxJoystickEvent swig_types[67]
1409 #define SWIGTYPE_p_wxCursor swig_types[68]
1410 #define SWIGTYPE_p_wxObject swig_types[69]
1411 #define SWIGTYPE_p_wxOutputStream swig_types[70]
1412 #define SWIGTYPE_p_wxDateTime swig_types[71]
1413 #define SWIGTYPE_p_wxPyDropSource swig_types[72]
1414 #define SWIGTYPE_p_unsigned_long swig_types[73]
1415 #define SWIGTYPE_p_wxKillError swig_types[74]
1416 #define SWIGTYPE_p_wxWindow swig_types[75]
1417 #define SWIGTYPE_p_wxString swig_types[76]
1418 #define SWIGTYPE_p_wxPyProcess swig_types[77]
1419 #define SWIGTYPE_p_wxBitmap swig_types[78]
1420 #define SWIGTYPE_p_wxConfig swig_types[79]
1421 #define SWIGTYPE_unsigned_int swig_types[80]
1422 #define SWIGTYPE_p_unsigned_int swig_types[81]
1423 #define SWIGTYPE_p_unsigned_char swig_types[82]
1424 #define SWIGTYPE_p_wxChar swig_types[83]
1425 #define SWIGTYPE_p_wxBusyInfo swig_types[84]
1426 #define SWIGTYPE_p_wxPyDropTarget swig_types[85]
1427 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[86]
1428 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxProcessEvent swig_types[88]
1430 #define SWIGTYPE_p_wxPyLog swig_types[89]
1431 #define SWIGTYPE_p_wxLogNull swig_types[90]
1432 #define SWIGTYPE_p_wxColour swig_types[91]
1433 #define SWIGTYPE_p_wxPyTimer swig_types[92]
1434 #define SWIGTYPE_p_wxConfigPathChanger swig_types[93]
1435 #define SWIGTYPE_p_wxDateSpan swig_types[94]
1436 static swig_type_info *swig_types[96];
1437
1438 /* -------- TYPES TABLE (END) -------- */
1439
1440
1441 /*-----------------------------------------------
1442 @(target):= _misc_.so
1443 ------------------------------------------------*/
1444 #define SWIG_init init_misc_
1445
1446 #define SWIG_name "_misc_"
1447
1448 #include "wx/wxPython/wxPython.h"
1449 #include "wx/wxPython/pyclasses.h"
1450 #include "wx/wxPython/pyistream.h"
1451
1452 static const wxString wxPyEmptyString(wxEmptyString);
1453
1454
1455
1456 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1457 #define SWIG_From_int PyInt_FromLong
1458 /*@@*/
1459
1460
1461 #include <limits.h>
1462
1463
1464 SWIGINTERN int
1465 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1466 const char *errmsg)
1467 {
1468 if (value < min_value) {
1469 if (errmsg) {
1470 PyErr_Format(PyExc_OverflowError,
1471 "value %ld is less than '%s' minimum %ld",
1472 value, errmsg, min_value);
1473 }
1474 return 0;
1475 } else if (value > max_value) {
1476 if (errmsg) {
1477 PyErr_Format(PyExc_OverflowError,
1478 "value %ld is greater than '%s' maximum %ld",
1479 value, errmsg, max_value);
1480 }
1481 return 0;
1482 }
1483 return 1;
1484 }
1485
1486
1487 SWIGINTERN int
1488 SWIG_AsVal_long(PyObject* obj, long* val)
1489 {
1490 if (PyNumber_Check(obj)) {
1491 if (val) *val = PyInt_AsLong(obj);
1492 return 1;
1493 }
1494 else {
1495 SWIG_type_error("number", obj);
1496 }
1497 return 0;
1498 }
1499
1500
1501 #if INT_MAX != LONG_MAX
1502 SWIGINTERN int
1503 SWIG_AsVal_int(PyObject *obj, int *val)
1504 {
1505 const char* errmsg = val ? "int" : (char*)0;
1506 long v;
1507 if (SWIG_AsVal_long(obj, &v)) {
1508 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1509 if (val) *val = (int)(v);
1510 return 1;
1511 } else {
1512 return 0;
1513 }
1514 } else {
1515 PyErr_Clear();
1516 }
1517 if (val) {
1518 SWIG_type_error(errmsg, obj);
1519 }
1520 return 0;
1521 }
1522 #else
1523 SWIGINTERNSHORT int
1524 SWIG_AsVal_int(PyObject *obj, int *val)
1525 {
1526 return SWIG_AsVal_long(obj,(long*)val);
1527 }
1528 #endif
1529
1530
1531 SWIGINTERNSHORT int
1532 SWIG_As_int(PyObject* obj)
1533 {
1534 int v;
1535 if (!SWIG_AsVal_int(obj, &v)) {
1536 /*
1537 this is needed to make valgrind/purify happier.
1538 */
1539 memset((void*)&v, 0, sizeof(int));
1540 }
1541 return v;
1542 }
1543
1544
1545 SWIGINTERNSHORT int
1546 SWIG_Check_int(PyObject* obj)
1547 {
1548 return SWIG_AsVal_int(obj, (int*)0);
1549 }
1550
1551 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1552
1553 #include <wx/stockitem.h>
1554
1555 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1556 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1557 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1558
1559 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1560 #define SWIG_From_long PyInt_FromLong
1561 /*@@*/
1562
1563
1564 SWIGINTERNSHORT long
1565 SWIG_As_long(PyObject* obj)
1566 {
1567 long v;
1568 if (!SWIG_AsVal_long(obj, &v)) {
1569 /*
1570 this is needed to make valgrind/purify happier.
1571 */
1572 memset((void*)&v, 0, sizeof(long));
1573 }
1574 return v;
1575 }
1576
1577
1578 SWIGINTERNSHORT int
1579 SWIG_Check_long(PyObject* obj)
1580 {
1581 return SWIG_AsVal_long(obj, (long*)0);
1582 }
1583
1584
1585 SWIGINTERN int
1586 SWIG_AsVal_bool(PyObject *obj, bool *val)
1587 {
1588 if (obj == Py_True) {
1589 if (val) *val = true;
1590 return 1;
1591 }
1592 if (obj == Py_False) {
1593 if (val) *val = false;
1594 return 1;
1595 }
1596 int res = 0;
1597 if (SWIG_AsVal_int(obj, &res)) {
1598 if (val) *val = res ? true : false;
1599 return 1;
1600 } else {
1601 PyErr_Clear();
1602 }
1603 if (val) {
1604 SWIG_type_error("bool", obj);
1605 }
1606 return 0;
1607 }
1608
1609
1610 SWIGINTERNSHORT bool
1611 SWIG_As_bool(PyObject* obj)
1612 {
1613 bool v;
1614 if (!SWIG_AsVal_bool(obj, &v)) {
1615 /*
1616 this is needed to make valgrind/purify happier.
1617 */
1618 memset((void*)&v, 0, sizeof(bool));
1619 }
1620 return v;
1621 }
1622
1623
1624 SWIGINTERNSHORT int
1625 SWIG_Check_bool(PyObject* obj)
1626 {
1627 return SWIG_AsVal_bool(obj, (bool*)0);
1628 }
1629
1630
1631 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1632 PyObject* o2;
1633 PyObject* o3;
1634
1635 if (!target) {
1636 target = o;
1637 } else if (target == Py_None) {
1638 Py_DECREF(Py_None);
1639 target = o;
1640 } else {
1641 if (!PyTuple_Check(target)) {
1642 o2 = target;
1643 target = PyTuple_New(1);
1644 PyTuple_SetItem(target, 0, o2);
1645 }
1646 o3 = PyTuple_New(1);
1647 PyTuple_SetItem(o3, 0, o);
1648
1649 o2 = target;
1650 target = PySequence_Concat(o2, o3);
1651 Py_DECREF(o2);
1652 Py_DECREF(o3);
1653 }
1654 return target;
1655 }
1656
1657
1658
1659 long wxGetFreeMemory()
1660 { wxPyRaiseNotImplemented(); return 0; }
1661
1662
1663 SWIGINTERN int
1664 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1665 {
1666 long v = 0;
1667 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1668 SWIG_type_error("unsigned number", obj);
1669 }
1670 else if (val)
1671 *val = (unsigned long)v;
1672 return 1;
1673 }
1674
1675
1676 SWIGINTERNSHORT unsigned long
1677 SWIG_As_unsigned_SS_long(PyObject* obj)
1678 {
1679 unsigned long v;
1680 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1681 /*
1682 this is needed to make valgrind/purify happier.
1683 */
1684 memset((void*)&v, 0, sizeof(unsigned long));
1685 }
1686 return v;
1687 }
1688
1689
1690 SWIGINTERNSHORT int
1691 SWIG_Check_unsigned_SS_long(PyObject* obj)
1692 {
1693 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1694 }
1695
1696
1697 SWIGINTERNSHORT PyObject*
1698 SWIG_From_unsigned_SS_long(unsigned long value)
1699 {
1700 return (value > LONG_MAX) ?
1701 PyLong_FromUnsignedLong(value)
1702 : PyInt_FromLong((long)(value));
1703 }
1704
1705
1706 void wxWakeUpMainThread() {}
1707
1708
1709 bool wxThread_IsMain() {
1710 #ifdef WXP_WITH_THREAD
1711 return wxThread::IsMain();
1712 #else
1713 return true;
1714 #endif
1715 }
1716
1717 static void wxCaret_Destroy(wxCaret *self){
1718 delete self;
1719 }
1720
1721 #include <wx/snglinst.h>
1722
1723
1724 #include <wx/tipdlg.h>
1725
1726
1727 class wxPyTipProvider : public wxTipProvider {
1728 public:
1729 wxPyTipProvider(size_t currentTip)
1730 : wxTipProvider(currentTip) {}
1731
1732 DEC_PYCALLBACK_STRING__pure(GetTip);
1733 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1734 PYPRIVATE;
1735 };
1736
1737 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1738 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1739
1740
1741 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1742
1743 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1744
1745 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1746 : wxTimer(owner, id)
1747 {
1748 if (owner == NULL) SetOwner(this);
1749 }
1750
1751
1752 void wxPyTimer::Notify() {
1753 bool found;
1754 bool blocked = wxPyBeginBlockThreads();
1755 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1756 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1757 wxPyEndBlockThreads(blocked);
1758 if (! found)
1759 wxTimer::Notify();
1760 }
1761 void wxPyTimer::base_Notify() {
1762 wxTimer::Notify();
1763 }
1764
1765
1766
1767 SWIGINTERN PyObject *
1768 SWIG_FromCharPtr(const char* cptr)
1769 {
1770 if (cptr) {
1771 size_t size = strlen(cptr);
1772 if (size > INT_MAX) {
1773 return SWIG_NewPointerObj((char*)(cptr),
1774 SWIG_TypeQuery("char *"), 0);
1775 } else {
1776 if (size != 0) {
1777 return PyString_FromStringAndSize(cptr, size);
1778 } else {
1779 return PyString_FromString(cptr);
1780 }
1781 }
1782 }
1783 Py_INCREF(Py_None);
1784 return Py_None;
1785 }
1786
1787
1788 SWIGINTERNSHORT int
1789 SWIG_CheckUnsignedLongInRange(unsigned long value,
1790 unsigned long max_value,
1791 const char *errmsg)
1792 {
1793 if (value > max_value) {
1794 if (errmsg) {
1795 PyErr_Format(PyExc_OverflowError,
1796 "value %lu is greater than '%s' minimum %lu",
1797 value, errmsg, max_value);
1798 }
1799 return 0;
1800 }
1801 return 1;
1802 }
1803
1804
1805 #if UINT_MAX != ULONG_MAX
1806 SWIGINTERN int
1807 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1808 {
1809 const char* errmsg = val ? "unsigned int" : (char*)0;
1810 unsigned long v;
1811 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1812 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1813 if (val) *val = (unsigned int)(v);
1814 return 1;
1815 }
1816 } else {
1817 PyErr_Clear();
1818 }
1819 if (val) {
1820 SWIG_type_error(errmsg, obj);
1821 }
1822 return 0;
1823 }
1824 #else
1825 SWIGINTERNSHORT unsigned int
1826 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1827 {
1828 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1829 }
1830 #endif
1831
1832
1833 SWIGINTERNSHORT unsigned int
1834 SWIG_As_unsigned_SS_int(PyObject* obj)
1835 {
1836 unsigned int v;
1837 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1838 /*
1839 this is needed to make valgrind/purify happier.
1840 */
1841 memset((void*)&v, 0, sizeof(unsigned int));
1842 }
1843 return v;
1844 }
1845
1846
1847 SWIGINTERNSHORT int
1848 SWIG_Check_unsigned_SS_int(PyObject* obj)
1849 {
1850 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1851 }
1852
1853 static wxString Log_TimeStamp(){
1854 wxString msg;
1855 wxLog::TimeStamp(&msg);
1856 return msg;
1857 }
1858 static void wxLog_Destroy(wxLog *self){ delete self; }
1859 // Make somce wrappers that double any % signs so they are 'escaped'
1860 void wxPyLogFatalError(const wxString& msg)
1861 {
1862 wxString m(msg);
1863 m.Replace(wxT("%"), wxT("%%"));
1864 wxLogFatalError(m);
1865 }
1866
1867 void wxPyLogError(const wxString& msg)
1868 {
1869 wxString m(msg);
1870 m.Replace(wxT("%"), wxT("%%"));
1871 wxLogError(m);
1872 }
1873
1874 void wxPyLogWarning(const wxString& msg)
1875 {
1876 wxString m(msg);
1877 m.Replace(wxT("%"), wxT("%%"));
1878 wxLogWarning(m);
1879 }
1880
1881 void wxPyLogMessage(const wxString& msg)
1882 {
1883 wxString m(msg);
1884 m.Replace(wxT("%"), wxT("%%"));
1885 wxLogMessage(m);
1886 }
1887
1888 void wxPyLogInfo(const wxString& msg)
1889 {
1890 wxString m(msg);
1891 m.Replace(wxT("%"), wxT("%%"));
1892 wxLogInfo(m);
1893 }
1894
1895 void wxPyLogDebug(const wxString& msg)
1896 {
1897 wxString m(msg);
1898 m.Replace(wxT("%"), wxT("%%"));
1899 wxLogDebug(m);
1900 }
1901
1902 void wxPyLogVerbose(const wxString& msg)
1903 {
1904 wxString m(msg);
1905 m.Replace(wxT("%"), wxT("%%"));
1906 wxLogVerbose(m);
1907 }
1908
1909 void wxPyLogStatus(const wxString& msg)
1910 {
1911 wxString m(msg);
1912 m.Replace(wxT("%"), wxT("%%"));
1913 wxLogStatus(m);
1914 }
1915
1916 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
1917 {
1918 wxString m(msg);
1919 m.Replace(wxT("%"), wxT("%%"));
1920 wxLogStatus(pFrame, m);
1921 }
1922
1923 void wxPyLogSysError(const wxString& msg)
1924 {
1925 wxString m(msg);
1926 m.Replace(wxT("%"), wxT("%%"));
1927 wxLogSysError(m);
1928 }
1929
1930 void wxPyLogGeneric(unsigned long level, const wxString& msg)
1931 {
1932 wxString m(msg);
1933 m.Replace(wxT("%"), wxT("%%"));
1934 wxLogGeneric(level, m);
1935 }
1936
1937 void wxPyLogTrace(unsigned long mask, const wxString& msg)
1938 {
1939 wxString m(msg);
1940 m.Replace(wxT("%"), wxT("%%"));
1941 wxLogTrace(mask, m);
1942 }
1943
1944 void wxPyLogTrace(const wxString& mask, const wxString& msg)
1945 {
1946 wxString m(msg);
1947 m.Replace(wxT("%"), wxT("%%"));
1948 wxLogTrace(mask, m);
1949 }
1950
1951
1952
1953 // A wxLog class that can be derived from in wxPython
1954 class wxPyLog : public wxLog {
1955 public:
1956 wxPyLog() : wxLog() {}
1957
1958 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
1959 bool found;
1960 bool blocked = wxPyBeginBlockThreads();
1961 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
1962 PyObject* s = wx2PyString(szString);
1963 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
1964 Py_DECREF(s);
1965 }
1966 wxPyEndBlockThreads(blocked);
1967 if (! found)
1968 wxLog::DoLog(level, szString, t);
1969 }
1970
1971 virtual void DoLogString(const wxChar *szString, time_t t) {
1972 bool found;
1973 bool blocked = wxPyBeginBlockThreads();
1974 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
1975 PyObject* s = wx2PyString(szString);
1976 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
1977 Py_DECREF(s);
1978 }
1979 wxPyEndBlockThreads(blocked);
1980 if (! found)
1981 wxLog::DoLogString(szString, t);
1982 }
1983
1984 PYPRIVATE;
1985 };
1986
1987
1988
1989
1990 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
1991
1992
1993 #include <wx/joystick.h>
1994
1995
1996 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
1997 // A C++ stub class for wxJoystick for platforms that don't have it.
1998 class wxJoystick : public wxObject {
1999 public:
2000 wxJoystick(int joystick = wxJOYSTICK1) {
2001 bool blocked = wxPyBeginBlockThreads();
2002 PyErr_SetString(PyExc_NotImplementedError,
2003 "wxJoystick is not available on this platform.");
2004 wxPyEndBlockThreads(blocked);
2005 }
2006 wxPoint GetPosition() { return wxPoint(-1,-1); }
2007 int GetZPosition() { return -1; }
2008 int GetButtonState() { return -1; }
2009 int GetPOVPosition() { return -1; }
2010 int GetPOVCTSPosition() { return -1; }
2011 int GetRudderPosition() { return -1; }
2012 int GetUPosition() { return -1; }
2013 int GetVPosition() { return -1; }
2014 int GetMovementThreshold() { return -1; }
2015 void SetMovementThreshold(int threshold) {}
2016
2017 bool IsOk(void) { return false; }
2018 int GetNumberJoysticks() { return -1; }
2019 int GetManufacturerId() { return -1; }
2020 int GetProductId() { return -1; }
2021 wxString GetProductName() { return wxEmptyString; }
2022 int GetXMin() { return -1; }
2023 int GetYMin() { return -1; }
2024 int GetZMin() { return -1; }
2025 int GetXMax() { return -1; }
2026 int GetYMax() { return -1; }
2027 int GetZMax() { return -1; }
2028 int GetNumberButtons() { return -1; }
2029 int GetNumberAxes() { return -1; }
2030 int GetMaxButtons() { return -1; }
2031 int GetMaxAxes() { return -1; }
2032 int GetPollingMin() { return -1; }
2033 int GetPollingMax() { return -1; }
2034 int GetRudderMin() { return -1; }
2035 int GetRudderMax() { return -1; }
2036 int GetUMin() { return -1; }
2037 int GetUMax() { return -1; }
2038 int GetVMin() { return -1; }
2039 int GetVMax() { return -1; }
2040
2041 bool HasRudder() { return false; }
2042 bool HasZ() { return false; }
2043 bool HasU() { return false; }
2044 bool HasV() { return false; }
2045 bool HasPOV() { return false; }
2046 bool HasPOV4Dir() { return false; }
2047 bool HasPOVCTS() { return false; }
2048
2049 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2050 bool ReleaseCapture() { return false; }
2051 };
2052 #endif
2053
2054
2055 #include <wx/sound.h>
2056
2057
2058 #if !wxUSE_SOUND
2059 // A C++ stub class for wxWave for platforms that don't have it.
2060 class wxSound : public wxObject
2061 {
2062 public:
2063 wxSound() {
2064 bool blocked = wxPyBeginBlockThreads();
2065 PyErr_SetString(PyExc_NotImplementedError,
2066 "wxSound is not available on this platform.");
2067 wxPyEndBlockThreads(blocked);
2068 }
2069 wxSound(const wxString&/*, bool*/) {
2070 bool blocked = wxPyBeginBlockThreads();
2071 PyErr_SetString(PyExc_NotImplementedError,
2072 "wxSound is not available on this platform.");
2073 wxPyEndBlockThreads(blocked);
2074 }
2075 wxSound(int, const wxByte*) {
2076 bool blocked = wxPyBeginBlockThreads();
2077 PyErr_SetString(PyExc_NotImplementedError,
2078 "wxSound is not available on this platform.");
2079 wxPyEndBlockThreads(blocked);
2080 }
2081
2082 ~wxSound() {};
2083
2084 bool Create(const wxString&/*, bool*/) { return false; }
2085 bool Create(int, const wxByte*) { return false; };
2086 bool IsOk() { return false; };
2087 bool Play(unsigned) const { return false; }
2088 static bool Play(const wxString&, unsigned) { return false; }
2089 static void Stop() {}
2090 };
2091
2092 #endif
2093
2094 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2095 if (fileName.Length() == 0)
2096 return new wxSound;
2097 else
2098 return new wxSound(fileName);
2099 }
2100 static wxSound *new_wxSound(PyObject *data){
2101 unsigned char* buffer; int size;
2102 wxSound *sound = NULL;
2103
2104 bool blocked = wxPyBeginBlockThreads();
2105 if (!PyArg_Parse(data, "t#", &buffer, &size))
2106 goto done;
2107 sound = new wxSound(size, buffer);
2108 done:
2109 wxPyEndBlockThreads(blocked);
2110 return sound;
2111 }
2112 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2113 #ifndef __WXMAC__
2114 unsigned char* buffer;
2115 int size;
2116 bool rv = false;
2117
2118 bool blocked = wxPyBeginBlockThreads();
2119 if (!PyArg_Parse(data, "t#", &buffer, &size))
2120 goto done;
2121 rv = self->Create(size, buffer);
2122 done:
2123 wxPyEndBlockThreads(blocked);
2124 return rv;
2125 #else
2126 bool blocked = wxPyBeginBlockThreads();
2127 PyErr_SetString(PyExc_NotImplementedError,
2128 "Create from data is not available on this platform.");
2129 wxPyEndBlockThreads(blocked);
2130 return false;
2131 #endif
2132 }
2133
2134 #include <wx/mimetype.h>
2135
2136 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2137 wxString str;
2138 if (self->GetMimeType(&str))
2139 return wx2PyString(str);
2140 else
2141 RETURN_NONE();
2142 }
2143 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2144 wxArrayString arr;
2145 if (self->GetMimeTypes(arr))
2146 return wxArrayString2PyList_helper(arr);
2147 else
2148 RETURN_NONE();
2149 }
2150 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2151 wxArrayString arr;
2152 if (self->GetExtensions(arr))
2153 return wxArrayString2PyList_helper(arr);
2154 else
2155 RETURN_NONE();
2156 }
2157 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2158 wxIconLocation loc;
2159 if (self->GetIcon(&loc))
2160 return new wxIcon(loc);
2161 else
2162 return NULL;
2163 }
2164 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2165 wxIconLocation loc;
2166 if (self->GetIcon(&loc)) {
2167 wxString iconFile = loc.GetFileName();
2168 int iconIndex = -1;
2169
2170
2171
2172 // Make a tuple and put the values in it
2173 bool blocked = wxPyBeginBlockThreads();
2174 PyObject* tuple = PyTuple_New(3);
2175 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2176 wxT("wxIcon"), true));
2177 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2178 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2179 wxPyEndBlockThreads(blocked);
2180 return tuple;
2181 }
2182 else
2183 RETURN_NONE();
2184 }
2185 static PyObject *wxFileType_GetDescription(wxFileType *self){
2186 wxString str;
2187 if (self->GetDescription(&str))
2188 return wx2PyString(str);
2189 else
2190 RETURN_NONE();
2191 }
2192 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2193 wxString str;
2194 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2195 return wx2PyString(str);
2196 else
2197 RETURN_NONE();
2198 }
2199 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2200 wxString str;
2201 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2202 return wx2PyString(str);
2203 else
2204 RETURN_NONE();
2205 }
2206 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2207 wxArrayString verbs;
2208 wxArrayString commands;
2209 if (self->GetAllCommands(&verbs, &commands,
2210 wxFileType::MessageParameters(filename, mimetype))) {
2211 bool blocked = wxPyBeginBlockThreads();
2212 PyObject* tuple = PyTuple_New(2);
2213 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2214 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2215 wxPyEndBlockThreads(blocked);
2216 return tuple;
2217 }
2218 else
2219 RETURN_NONE();
2220 }
2221 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2222 return wxFileType::ExpandCommand(command,
2223 wxFileType::MessageParameters(filename, mimetype));
2224 }
2225 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2226 wxArrayString arr;
2227 self->EnumAllFileTypes(arr);
2228 return wxArrayString2PyList_helper(arr);
2229 }
2230
2231 #include <wx/artprov.h>
2232
2233 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2234 static const wxString wxPyART_MENU(wxART_MENU);
2235 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2236 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2237 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2238 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2239 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2240 static const wxString wxPyART_OTHER(wxART_OTHER);
2241 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2242 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2243 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2244 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2245 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2246 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2247 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2248 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2249 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2250 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2251 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2252 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2253 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2254 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2255 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2256 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2257 static const wxString wxPyART_PRINT(wxART_PRINT);
2258 static const wxString wxPyART_HELP(wxART_HELP);
2259 static const wxString wxPyART_TIP(wxART_TIP);
2260 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2261 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2262 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2263 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2264 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2265 static const wxString wxPyART_CDROM(wxART_CDROM);
2266 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2267 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2268 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2269 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2270 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2271 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2272 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2273 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2274 static const wxString wxPyART_ERROR(wxART_ERROR);
2275 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2276 static const wxString wxPyART_WARNING(wxART_WARNING);
2277 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2278 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2279 static const wxString wxPyART_COPY(wxART_COPY);
2280 static const wxString wxPyART_CUT(wxART_CUT);
2281 static const wxString wxPyART_PASTE(wxART_PASTE);
2282 static const wxString wxPyART_DELETE(wxART_DELETE);
2283 static const wxString wxPyART_UNDO(wxART_UNDO);
2284 static const wxString wxPyART_REDO(wxART_REDO);
2285 static const wxString wxPyART_QUIT(wxART_QUIT);
2286 static const wxString wxPyART_FIND(wxART_FIND);
2287 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2288 // Python aware wxArtProvider
2289 class wxPyArtProvider : public wxArtProvider {
2290 public:
2291
2292 virtual wxBitmap CreateBitmap(const wxArtID& id,
2293 const wxArtClient& client,
2294 const wxSize& size) {
2295 wxBitmap rval = wxNullBitmap;
2296 bool blocked = wxPyBeginBlockThreads();
2297 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2298 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2299 PyObject* ro;
2300 wxBitmap* ptr;
2301 PyObject* s1, *s2;
2302 s1 = wx2PyString(id);
2303 s2 = wx2PyString(client);
2304 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2305 Py_DECREF(so);
2306 Py_DECREF(s1);
2307 Py_DECREF(s2);
2308 if (ro) {
2309 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2310 rval = *ptr;
2311 Py_DECREF(ro);
2312 }
2313 }
2314 wxPyEndBlockThreads(blocked);
2315 return rval;
2316 }
2317
2318 PYPRIVATE;
2319 };
2320
2321 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2322
2323
2324
2325 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2326 PyObject* ret = PyTuple_New(3);
2327 if (ret) {
2328 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2329 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2330 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2331 }
2332 return ret;
2333 }
2334
2335 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2336 bool cont;
2337 long index = 0;
2338 wxString value;
2339
2340 cont = self->GetFirstGroup(value, index);
2341 return __EnumerationHelper(cont, value, index);
2342 }
2343 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2344 bool cont;
2345 wxString value;
2346
2347 cont = self->GetNextGroup(value, index);
2348 return __EnumerationHelper(cont, value, index);
2349 }
2350 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2351 bool cont;
2352 long index = 0;
2353 wxString value;
2354
2355 cont = self->GetFirstEntry(value, index);
2356 return __EnumerationHelper(cont, value, index);
2357 }
2358 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2359 bool cont;
2360 wxString value;
2361
2362 cont = self->GetNextEntry(value, index);
2363 return __EnumerationHelper(cont, value, index);
2364 }
2365 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2366 long rv;
2367 self->Read(key, &rv, defaultVal);
2368 return rv;
2369 }
2370
2371 SWIGINTERN int
2372 SWIG_AsVal_double(PyObject *obj, double* val)
2373 {
2374 if (PyNumber_Check(obj)) {
2375 if (val) *val = PyFloat_AsDouble(obj);
2376 return 1;
2377 }
2378 else {
2379 SWIG_type_error("number", obj);
2380 }
2381 return 0;
2382 }
2383
2384
2385 SWIGINTERNSHORT double
2386 SWIG_As_double(PyObject* obj)
2387 {
2388 double v;
2389 if (!SWIG_AsVal_double(obj, &v)) {
2390 /*
2391 this is needed to make valgrind/purify happier.
2392 */
2393 memset((void*)&v, 0, sizeof(double));
2394 }
2395 return v;
2396 }
2397
2398
2399 SWIGINTERNSHORT int
2400 SWIG_Check_double(PyObject* obj)
2401 {
2402 return SWIG_AsVal_double(obj, (double*)0);
2403 }
2404
2405 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2406 double rv;
2407 self->Read(key, &rv, defaultVal);
2408 return rv;
2409 }
2410
2411 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2412 #define SWIG_From_double PyFloat_FromDouble
2413 /*@@*/
2414
2415 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2416 bool rv;
2417 self->Read(key, &rv, defaultVal);
2418 return rv;
2419 }
2420
2421 #include <wx/datetime.h>
2422
2423 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2424 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2425
2426 #define LOCAL_TZ wxDateTime::Local
2427
2428
2429 #if UINT_MAX < LONG_MAX
2430 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2431 #define SWIG_From_unsigned_SS_int SWIG_From_long
2432 /*@@*/
2433 #else
2434 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2435 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2436 /*@@*/
2437 #endif
2438
2439 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2440 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2441 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2442 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2443 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2444 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2445 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2446 return (*self < *other);
2447 }
2448 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2449 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2450 return (*self <= *other);
2451 }
2452 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2453 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2454 return (*self > *other);
2455 }
2456 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2457 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2458 return (*self >= *other);
2459 }
2460 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2461 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2462 return (*self == *other);
2463 }
2464 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2465 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2466 return (*self != *other);
2467 }
2468 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2469 const wxChar* rv;
2470 const wxChar* _date = date;
2471 rv = self->ParseRfc822Date(_date);
2472 if (rv == NULL) return -1;
2473 return rv - _date;
2474 }
2475 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2476 const wxChar* rv;
2477 const wxChar* _date = date;
2478 rv = self->ParseFormat(_date, format, dateDef);
2479 if (rv == NULL) return -1;
2480 return rv - _date;
2481 }
2482 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2483 const wxChar* rv;
2484 const wxChar* _datetime = datetime;
2485 rv = self->ParseDateTime(_datetime);
2486 if (rv == NULL) return -1;
2487 return rv - _datetime;
2488 }
2489 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2490 const wxChar* rv;
2491 const wxChar* _date = date;
2492 rv = self->ParseDate(_date);
2493 if (rv == NULL) return -1;
2494 return rv - _date;
2495 }
2496 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2497 const wxChar* rv;
2498 const wxChar* _time = time;
2499 rv = self->ParseTime(_time);
2500 if (rv == NULL) return -1;
2501 return rv - _time;
2502 }
2503 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2504 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2505 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2506 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2507 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2508 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2509 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2510 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2511 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2512 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2513 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2514 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2515 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2516 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2517 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2518 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2519
2520 #include <wx/dataobj.h>
2521
2522 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2523 size_t count = self->GetFormatCount(dir);
2524 wxDataFormat* formats = new wxDataFormat[count];
2525 self->GetAllFormats(formats, dir);
2526
2527 bool blocked = wxPyBeginBlockThreads();
2528 PyObject* list = PyList_New(count);
2529 for (size_t i=0; i<count; i++) {
2530 wxDataFormat* format = new wxDataFormat(formats[i]);
2531 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2532 PyList_Append(list, obj);
2533 Py_DECREF(obj);
2534 }
2535 wxPyEndBlockThreads(blocked);
2536 delete [] formats;
2537 return list;
2538 }
2539 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2540 PyObject* rval = NULL;
2541 size_t size = self->GetDataSize(format);
2542 bool blocked = wxPyBeginBlockThreads();
2543 if (size) {
2544 char* buf = new char[size];
2545 if (self->GetDataHere(format, buf))
2546 rval = PyString_FromStringAndSize(buf, size);
2547 delete [] buf;
2548 }
2549 if (! rval) {
2550 rval = Py_None;
2551 Py_INCREF(rval);
2552 }
2553 wxPyEndBlockThreads(blocked);
2554 return rval;
2555 }
2556 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2557 bool rval;
2558 bool blocked = wxPyBeginBlockThreads();
2559 if (PyString_Check(data)) {
2560 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2561 }
2562 else {
2563 // raise a TypeError if not a string
2564 PyErr_SetString(PyExc_TypeError, "String expected.");
2565 rval = false;
2566 }
2567 wxPyEndBlockThreads(blocked);
2568 return rval;
2569 }
2570 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2571 PyObject* rval = NULL;
2572 size_t size = self->GetDataSize();
2573 bool blocked = wxPyBeginBlockThreads();
2574 if (size) {
2575 char* buf = new char[size];
2576 if (self->GetDataHere(buf))
2577 rval = PyString_FromStringAndSize(buf, size);
2578 delete [] buf;
2579 }
2580 if (! rval) {
2581 rval = Py_None;
2582 Py_INCREF(rval);
2583 }
2584 wxPyEndBlockThreads(blocked);
2585 return rval;
2586 }
2587 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2588 bool rval;
2589 bool blocked = wxPyBeginBlockThreads();
2590 if (PyString_Check(data)) {
2591 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2592 }
2593 else {
2594 // raise a TypeError if not a string
2595 PyErr_SetString(PyExc_TypeError, "String expected.");
2596 rval = false;
2597 }
2598 wxPyEndBlockThreads(blocked);
2599 return rval;
2600 }
2601 // Create a new class for wxPython to use
2602 class wxPyDataObjectSimple : public wxDataObjectSimple {
2603 public:
2604 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2605 : wxDataObjectSimple(format) {}
2606
2607 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2608 bool GetDataHere(void *buf) const;
2609 bool SetData(size_t len, const void *buf) const;
2610 PYPRIVATE;
2611 };
2612
2613 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2614
2615 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2616 // We need to get the data for this object and write it to buf. I think
2617 // the best way to do this for wxPython is to have the Python method
2618 // return either a string or None and then act appropriately with the
2619 // C++ version.
2620
2621 bool rval = false;
2622 bool blocked = wxPyBeginBlockThreads();
2623 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2624 PyObject* ro;
2625 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2626 if (ro) {
2627 rval = (ro != Py_None && PyString_Check(ro));
2628 if (rval)
2629 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2630 Py_DECREF(ro);
2631 }
2632 }
2633 wxPyEndBlockThreads(blocked);
2634 return rval;
2635 }
2636
2637 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2638 // For this one we simply need to make a string from buf and len
2639 // and send it to the Python method.
2640 bool rval = false;
2641 bool blocked = wxPyBeginBlockThreads();
2642 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2643 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2644 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2645 Py_DECREF(data);
2646 }
2647 wxPyEndBlockThreads(blocked);
2648 return rval;
2649 }
2650
2651 // Create a new class for wxPython to use
2652 class wxPyTextDataObject : public wxTextDataObject {
2653 public:
2654 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2655 : wxTextDataObject(text) {}
2656
2657 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2658 DEC_PYCALLBACK_STRING__const(GetText);
2659 DEC_PYCALLBACK__STRING(SetText);
2660 PYPRIVATE;
2661 };
2662
2663 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2664 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2665 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2666
2667
2668 // Create a new class for wxPython to use
2669 class wxPyBitmapDataObject : public wxBitmapDataObject {
2670 public:
2671 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2672 : wxBitmapDataObject(bitmap) {}
2673
2674 wxBitmap GetBitmap() const;
2675 void SetBitmap(const wxBitmap& bitmap);
2676 PYPRIVATE;
2677 };
2678
2679 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2680 wxBitmap* rval = &wxNullBitmap;
2681 bool blocked = wxPyBeginBlockThreads();
2682 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2683 PyObject* ro;
2684 wxBitmap* ptr;
2685 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2686 if (ro) {
2687 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2688 rval = ptr;
2689 Py_DECREF(ro);
2690 }
2691 }
2692 wxPyEndBlockThreads(blocked);
2693 return *rval;
2694 }
2695
2696 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2697 bool blocked = wxPyBeginBlockThreads();
2698 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2699 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2700 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2701 Py_DECREF(bo);
2702 }
2703 wxPyEndBlockThreads(blocked);
2704 }
2705
2706 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2707 return new wxCustomDataObject(wxDataFormat(formatName));
2708 }
2709 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2710 bool rval;
2711 bool blocked = wxPyBeginBlockThreads();
2712 if (PyString_Check(data)) {
2713 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2714 }
2715 else {
2716 // raise a TypeError if not a string
2717 PyErr_SetString(PyExc_TypeError, "String expected.");
2718 rval = false;
2719 }
2720 wxPyEndBlockThreads(blocked);
2721 return rval;
2722 }
2723 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2724 PyObject* obj;
2725 bool blocked = wxPyBeginBlockThreads();
2726 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2727 wxPyEndBlockThreads(blocked);
2728 return obj;
2729 }
2730
2731 class wxMetafileDataObject : public wxDataObjectSimple
2732 {
2733 public:
2734 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2735 };
2736
2737
2738 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2739
2740
2741 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2742 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2743 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2744 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2745 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2746
2747
2748 class wxPyTextDropTarget : public wxTextDropTarget {
2749 public:
2750 wxPyTextDropTarget() {}
2751
2752 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2753
2754 DEC_PYCALLBACK__(OnLeave);
2755 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2756 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2757 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2758 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2759
2760 PYPRIVATE;
2761 };
2762
2763 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2764 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2765 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2766 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2767 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2768 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2769
2770
2771
2772 class wxPyFileDropTarget : public wxFileDropTarget {
2773 public:
2774 wxPyFileDropTarget() {}
2775
2776 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2777
2778 DEC_PYCALLBACK__(OnLeave);
2779 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2780 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2781 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2782 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2783
2784 PYPRIVATE;
2785 };
2786
2787 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2788 const wxArrayString& filenames) {
2789 bool rval = false;
2790 bool blocked = wxPyBeginBlockThreads();
2791 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2792 PyObject* list = wxArrayString2PyList_helper(filenames);
2793 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2794 Py_DECREF(list);
2795 }
2796 wxPyEndBlockThreads(blocked);
2797 return rval;
2798 }
2799
2800
2801
2802 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2803 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2804 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2805 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2806 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2807
2808
2809
2810
2811 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2812
2813 #include <wx/display.h>
2814
2815 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2816 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2817
2818 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2819 #if !wxUSE_DISPLAY
2820 #include <wx/dynarray.h>
2821 #include <wx/vidmode.h>
2822
2823 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2824 #include "wx/arrimpl.cpp"
2825 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2826 const wxVideoMode wxDefaultVideoMode;
2827
2828 class wxDisplay
2829 {
2830 public:
2831 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2832 ~wxDisplay() {}
2833
2834 static size_t GetCount()
2835 { wxPyRaiseNotImplemented(); return 0; }
2836
2837 static int GetFromPoint(const wxPoint& pt)
2838 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2839 static int GetFromWindow(wxWindow *window)
2840 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2841
2842 virtual bool IsOk() const { return false; }
2843 virtual wxRect GetGeometry() const { wxRect r; return r; }
2844 virtual wxString GetName() const { return wxEmptyString; }
2845 bool IsPrimary() const { return false; }
2846
2847 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2848 { wxArrayVideoModes a; return a; }
2849
2850 virtual wxVideoMode GetCurrentMode() const
2851 { return wxDefaultVideoMode; }
2852
2853 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2854 { return false; }
2855
2856 void ResetMode() {}
2857 };
2858 #endif
2859
2860 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2861 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2862 PyObject* pyList = NULL;
2863 wxArrayVideoModes arr = self->GetModes(mode);
2864 bool blocked = wxPyBeginBlockThreads();
2865 pyList = PyList_New(0);
2866 for (int i=0; i < arr.GetCount(); i++) {
2867 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2868 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2869 PyList_Append(pyList, pyObj);
2870 Py_DECREF(pyObj);
2871 }
2872 wxPyEndBlockThreads(blocked);
2873 return pyList;
2874 }
2875
2876 #include <wx/stdpaths.h>
2877
2878 static wxStandardPaths *StandardPaths_Get(){
2879 return (wxStandardPaths*) &wxStandardPaths::Get();
2880 }
2881 #ifdef __cplusplus
2882 extern "C" {
2883 #endif
2884 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2885 PyObject *resultobj;
2886 wxSystemColour arg1 ;
2887 wxColour result;
2888 PyObject * obj0 = 0 ;
2889 char *kwnames[] = {
2890 (char *) "index", NULL
2891 };
2892
2893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2894 {
2895 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2896 if (SWIG_arg_fail(1)) SWIG_fail;
2897 }
2898 {
2899 if (!wxPyCheckForApp()) SWIG_fail;
2900 PyThreadState* __tstate = wxPyBeginAllowThreads();
2901 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2902
2903 wxPyEndAllowThreads(__tstate);
2904 if (PyErr_Occurred()) SWIG_fail;
2905 }
2906 {
2907 wxColour * resultptr;
2908 resultptr = new wxColour((wxColour &)(result));
2909 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2910 }
2911 return resultobj;
2912 fail:
2913 return NULL;
2914 }
2915
2916
2917 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
2918 PyObject *resultobj;
2919 wxSystemFont arg1 ;
2920 wxFont result;
2921 PyObject * obj0 = 0 ;
2922 char *kwnames[] = {
2923 (char *) "index", NULL
2924 };
2925
2926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
2927 {
2928 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
2929 if (SWIG_arg_fail(1)) SWIG_fail;
2930 }
2931 {
2932 if (!wxPyCheckForApp()) SWIG_fail;
2933 PyThreadState* __tstate = wxPyBeginAllowThreads();
2934 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
2935
2936 wxPyEndAllowThreads(__tstate);
2937 if (PyErr_Occurred()) SWIG_fail;
2938 }
2939 {
2940 wxFont * resultptr;
2941 resultptr = new wxFont((wxFont &)(result));
2942 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
2943 }
2944 return resultobj;
2945 fail:
2946 return NULL;
2947 }
2948
2949
2950 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
2951 PyObject *resultobj;
2952 wxSystemMetric arg1 ;
2953 int result;
2954 PyObject * obj0 = 0 ;
2955 char *kwnames[] = {
2956 (char *) "index", NULL
2957 };
2958
2959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
2960 {
2961 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
2962 if (SWIG_arg_fail(1)) SWIG_fail;
2963 }
2964 {
2965 if (!wxPyCheckForApp()) SWIG_fail;
2966 PyThreadState* __tstate = wxPyBeginAllowThreads();
2967 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
2968
2969 wxPyEndAllowThreads(__tstate);
2970 if (PyErr_Occurred()) SWIG_fail;
2971 }
2972 {
2973 resultobj = SWIG_From_int((int)(result));
2974 }
2975 return resultobj;
2976 fail:
2977 return NULL;
2978 }
2979
2980
2981 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
2982 PyObject *resultobj;
2983 wxSystemFeature arg1 ;
2984 bool result;
2985 PyObject * obj0 = 0 ;
2986 char *kwnames[] = {
2987 (char *) "index", NULL
2988 };
2989
2990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
2991 {
2992 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
2993 if (SWIG_arg_fail(1)) SWIG_fail;
2994 }
2995 {
2996 if (!wxPyCheckForApp()) SWIG_fail;
2997 PyThreadState* __tstate = wxPyBeginAllowThreads();
2998 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
2999
3000 wxPyEndAllowThreads(__tstate);
3001 if (PyErr_Occurred()) SWIG_fail;
3002 }
3003 {
3004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3005 }
3006 return resultobj;
3007 fail:
3008 return NULL;
3009 }
3010
3011
3012 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3013 PyObject *resultobj;
3014 wxSystemScreenType result;
3015 char *kwnames[] = {
3016 NULL
3017 };
3018
3019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3020 {
3021 if (!wxPyCheckForApp()) SWIG_fail;
3022 PyThreadState* __tstate = wxPyBeginAllowThreads();
3023 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3024
3025 wxPyEndAllowThreads(__tstate);
3026 if (PyErr_Occurred()) SWIG_fail;
3027 }
3028 resultobj = SWIG_From_int((result));
3029 return resultobj;
3030 fail:
3031 return NULL;
3032 }
3033
3034
3035 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3036 PyObject *resultobj;
3037 wxSystemScreenType arg1 ;
3038 PyObject * obj0 = 0 ;
3039 char *kwnames[] = {
3040 (char *) "screen", NULL
3041 };
3042
3043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3044 {
3045 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3046 if (SWIG_arg_fail(1)) SWIG_fail;
3047 }
3048 {
3049 if (!wxPyCheckForApp()) SWIG_fail;
3050 PyThreadState* __tstate = wxPyBeginAllowThreads();
3051 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3052
3053 wxPyEndAllowThreads(__tstate);
3054 if (PyErr_Occurred()) SWIG_fail;
3055 }
3056 Py_INCREF(Py_None); resultobj = Py_None;
3057 return resultobj;
3058 fail:
3059 return NULL;
3060 }
3061
3062
3063 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3064 PyObject *obj;
3065 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3066 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3067 Py_INCREF(obj);
3068 return Py_BuildValue((char *)"");
3069 }
3070 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3071 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3072 return 1;
3073 }
3074
3075
3076 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3077 PyObject *pyobj;
3078
3079 {
3080 #if wxUSE_UNICODE
3081 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3082 #else
3083 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3084 #endif
3085 }
3086 return pyobj;
3087 }
3088
3089
3090 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3091 PyObject *resultobj;
3092 wxSystemOptions *result;
3093 char *kwnames[] = {
3094 NULL
3095 };
3096
3097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3098 {
3099 PyThreadState* __tstate = wxPyBeginAllowThreads();
3100 result = (wxSystemOptions *)new wxSystemOptions();
3101
3102 wxPyEndAllowThreads(__tstate);
3103 if (PyErr_Occurred()) SWIG_fail;
3104 }
3105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3106 return resultobj;
3107 fail:
3108 return NULL;
3109 }
3110
3111
3112 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3113 PyObject *resultobj;
3114 wxString *arg1 = 0 ;
3115 wxString *arg2 = 0 ;
3116 bool temp1 = false ;
3117 bool temp2 = false ;
3118 PyObject * obj0 = 0 ;
3119 PyObject * obj1 = 0 ;
3120 char *kwnames[] = {
3121 (char *) "name",(char *) "value", NULL
3122 };
3123
3124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3125 {
3126 arg1 = wxString_in_helper(obj0);
3127 if (arg1 == NULL) SWIG_fail;
3128 temp1 = true;
3129 }
3130 {
3131 arg2 = wxString_in_helper(obj1);
3132 if (arg2 == NULL) SWIG_fail;
3133 temp2 = true;
3134 }
3135 {
3136 PyThreadState* __tstate = wxPyBeginAllowThreads();
3137 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3138
3139 wxPyEndAllowThreads(__tstate);
3140 if (PyErr_Occurred()) SWIG_fail;
3141 }
3142 Py_INCREF(Py_None); resultobj = Py_None;
3143 {
3144 if (temp1)
3145 delete arg1;
3146 }
3147 {
3148 if (temp2)
3149 delete arg2;
3150 }
3151 return resultobj;
3152 fail:
3153 {
3154 if (temp1)
3155 delete arg1;
3156 }
3157 {
3158 if (temp2)
3159 delete arg2;
3160 }
3161 return NULL;
3162 }
3163
3164
3165 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3166 PyObject *resultobj;
3167 wxString *arg1 = 0 ;
3168 int arg2 ;
3169 bool temp1 = false ;
3170 PyObject * obj0 = 0 ;
3171 PyObject * obj1 = 0 ;
3172 char *kwnames[] = {
3173 (char *) "name",(char *) "value", NULL
3174 };
3175
3176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3177 {
3178 arg1 = wxString_in_helper(obj0);
3179 if (arg1 == NULL) SWIG_fail;
3180 temp1 = true;
3181 }
3182 {
3183 arg2 = (int)(SWIG_As_int(obj1));
3184 if (SWIG_arg_fail(2)) SWIG_fail;
3185 }
3186 {
3187 PyThreadState* __tstate = wxPyBeginAllowThreads();
3188 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3189
3190 wxPyEndAllowThreads(__tstate);
3191 if (PyErr_Occurred()) SWIG_fail;
3192 }
3193 Py_INCREF(Py_None); resultobj = Py_None;
3194 {
3195 if (temp1)
3196 delete arg1;
3197 }
3198 return resultobj;
3199 fail:
3200 {
3201 if (temp1)
3202 delete arg1;
3203 }
3204 return NULL;
3205 }
3206
3207
3208 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3209 PyObject *resultobj;
3210 wxString *arg1 = 0 ;
3211 wxString result;
3212 bool temp1 = false ;
3213 PyObject * obj0 = 0 ;
3214 char *kwnames[] = {
3215 (char *) "name", NULL
3216 };
3217
3218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3219 {
3220 arg1 = wxString_in_helper(obj0);
3221 if (arg1 == NULL) SWIG_fail;
3222 temp1 = true;
3223 }
3224 {
3225 PyThreadState* __tstate = wxPyBeginAllowThreads();
3226 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3227
3228 wxPyEndAllowThreads(__tstate);
3229 if (PyErr_Occurred()) SWIG_fail;
3230 }
3231 {
3232 #if wxUSE_UNICODE
3233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3234 #else
3235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3236 #endif
3237 }
3238 {
3239 if (temp1)
3240 delete arg1;
3241 }
3242 return resultobj;
3243 fail:
3244 {
3245 if (temp1)
3246 delete arg1;
3247 }
3248 return NULL;
3249 }
3250
3251
3252 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3253 PyObject *resultobj;
3254 wxString *arg1 = 0 ;
3255 int result;
3256 bool temp1 = false ;
3257 PyObject * obj0 = 0 ;
3258 char *kwnames[] = {
3259 (char *) "name", NULL
3260 };
3261
3262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3263 {
3264 arg1 = wxString_in_helper(obj0);
3265 if (arg1 == NULL) SWIG_fail;
3266 temp1 = true;
3267 }
3268 {
3269 PyThreadState* __tstate = wxPyBeginAllowThreads();
3270 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3271
3272 wxPyEndAllowThreads(__tstate);
3273 if (PyErr_Occurred()) SWIG_fail;
3274 }
3275 {
3276 resultobj = SWIG_From_int((int)(result));
3277 }
3278 {
3279 if (temp1)
3280 delete arg1;
3281 }
3282 return resultobj;
3283 fail:
3284 {
3285 if (temp1)
3286 delete arg1;
3287 }
3288 return NULL;
3289 }
3290
3291
3292 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3293 PyObject *resultobj;
3294 wxString *arg1 = 0 ;
3295 bool result;
3296 bool temp1 = false ;
3297 PyObject * obj0 = 0 ;
3298 char *kwnames[] = {
3299 (char *) "name", NULL
3300 };
3301
3302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3303 {
3304 arg1 = wxString_in_helper(obj0);
3305 if (arg1 == NULL) SWIG_fail;
3306 temp1 = true;
3307 }
3308 {
3309 PyThreadState* __tstate = wxPyBeginAllowThreads();
3310 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3311
3312 wxPyEndAllowThreads(__tstate);
3313 if (PyErr_Occurred()) SWIG_fail;
3314 }
3315 {
3316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3317 }
3318 {
3319 if (temp1)
3320 delete arg1;
3321 }
3322 return resultobj;
3323 fail:
3324 {
3325 if (temp1)
3326 delete arg1;
3327 }
3328 return NULL;
3329 }
3330
3331
3332 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3333 PyObject *obj;
3334 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3335 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3336 Py_INCREF(obj);
3337 return Py_BuildValue((char *)"");
3338 }
3339 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3340 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3341 return 1;
3342 }
3343
3344
3345 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3346 PyObject *pyobj;
3347
3348 {
3349 #if wxUSE_UNICODE
3350 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3351 #else
3352 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3353 #endif
3354 }
3355 return pyobj;
3356 }
3357
3358
3359 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3360 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3361 return 1;
3362 }
3363
3364
3365 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3366 PyObject *pyobj;
3367
3368 {
3369 #if wxUSE_UNICODE
3370 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3371 #else
3372 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3373 #endif
3374 }
3375 return pyobj;
3376 }
3377
3378
3379 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3380 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3381 return 1;
3382 }
3383
3384
3385 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3386 PyObject *pyobj;
3387
3388 {
3389 #if wxUSE_UNICODE
3390 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3391 #else
3392 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3393 #endif
3394 }
3395 return pyobj;
3396 }
3397
3398
3399 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3400 PyObject *resultobj;
3401 long result;
3402 char *kwnames[] = {
3403 NULL
3404 };
3405
3406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3407 {
3408 PyThreadState* __tstate = wxPyBeginAllowThreads();
3409 result = (long)wxNewId();
3410
3411 wxPyEndAllowThreads(__tstate);
3412 if (PyErr_Occurred()) SWIG_fail;
3413 }
3414 {
3415 resultobj = SWIG_From_long((long)(result));
3416 }
3417 return resultobj;
3418 fail:
3419 return NULL;
3420 }
3421
3422
3423 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3424 PyObject *resultobj;
3425 long arg1 ;
3426 PyObject * obj0 = 0 ;
3427 char *kwnames[] = {
3428 (char *) "id", NULL
3429 };
3430
3431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3432 {
3433 arg1 = (long)(SWIG_As_long(obj0));
3434 if (SWIG_arg_fail(1)) SWIG_fail;
3435 }
3436 {
3437 PyThreadState* __tstate = wxPyBeginAllowThreads();
3438 wxRegisterId(arg1);
3439
3440 wxPyEndAllowThreads(__tstate);
3441 if (PyErr_Occurred()) SWIG_fail;
3442 }
3443 Py_INCREF(Py_None); resultobj = Py_None;
3444 return resultobj;
3445 fail:
3446 return NULL;
3447 }
3448
3449
3450 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3451 PyObject *resultobj;
3452 long result;
3453 char *kwnames[] = {
3454 NULL
3455 };
3456
3457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3458 {
3459 PyThreadState* __tstate = wxPyBeginAllowThreads();
3460 result = (long)wxGetCurrentId();
3461
3462 wxPyEndAllowThreads(__tstate);
3463 if (PyErr_Occurred()) SWIG_fail;
3464 }
3465 {
3466 resultobj = SWIG_From_long((long)(result));
3467 }
3468 return resultobj;
3469 fail:
3470 return NULL;
3471 }
3472
3473
3474 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3475 PyObject *resultobj;
3476 int arg1 ;
3477 bool result;
3478 PyObject * obj0 = 0 ;
3479 char *kwnames[] = {
3480 (char *) "id", NULL
3481 };
3482
3483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3484 {
3485 arg1 = (int)(SWIG_As_int(obj0));
3486 if (SWIG_arg_fail(1)) SWIG_fail;
3487 }
3488 {
3489 PyThreadState* __tstate = wxPyBeginAllowThreads();
3490 result = (bool)wxIsStockID(arg1);
3491
3492 wxPyEndAllowThreads(__tstate);
3493 if (PyErr_Occurred()) SWIG_fail;
3494 }
3495 {
3496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3497 }
3498 return resultobj;
3499 fail:
3500 return NULL;
3501 }
3502
3503
3504 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3505 PyObject *resultobj;
3506 int arg1 ;
3507 wxString *arg2 = 0 ;
3508 bool result;
3509 bool temp2 = false ;
3510 PyObject * obj0 = 0 ;
3511 PyObject * obj1 = 0 ;
3512 char *kwnames[] = {
3513 (char *) "id",(char *) "label", NULL
3514 };
3515
3516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3517 {
3518 arg1 = (int)(SWIG_As_int(obj0));
3519 if (SWIG_arg_fail(1)) SWIG_fail;
3520 }
3521 {
3522 arg2 = wxString_in_helper(obj1);
3523 if (arg2 == NULL) SWIG_fail;
3524 temp2 = true;
3525 }
3526 {
3527 PyThreadState* __tstate = wxPyBeginAllowThreads();
3528 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3529
3530 wxPyEndAllowThreads(__tstate);
3531 if (PyErr_Occurred()) SWIG_fail;
3532 }
3533 {
3534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3535 }
3536 {
3537 if (temp2)
3538 delete arg2;
3539 }
3540 return resultobj;
3541 fail:
3542 {
3543 if (temp2)
3544 delete arg2;
3545 }
3546 return NULL;
3547 }
3548
3549
3550 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3551 PyObject *resultobj;
3552 int arg1 ;
3553 bool arg2 = (bool) true ;
3554 wxString arg3 = (wxString) wxPyEmptyString ;
3555 wxString result;
3556 PyObject * obj0 = 0 ;
3557 PyObject * obj1 = 0 ;
3558 PyObject * obj2 = 0 ;
3559 char *kwnames[] = {
3560 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3561 };
3562
3563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3564 {
3565 arg1 = (int)(SWIG_As_int(obj0));
3566 if (SWIG_arg_fail(1)) SWIG_fail;
3567 }
3568 if (obj1) {
3569 {
3570 arg2 = (bool)(SWIG_As_bool(obj1));
3571 if (SWIG_arg_fail(2)) SWIG_fail;
3572 }
3573 }
3574 if (obj2) {
3575 {
3576 wxString* sptr = wxString_in_helper(obj2);
3577 if (sptr == NULL) SWIG_fail;
3578 arg3 = *sptr;
3579 delete sptr;
3580 }
3581 }
3582 {
3583 PyThreadState* __tstate = wxPyBeginAllowThreads();
3584 result = wxGetStockLabel(arg1,arg2,arg3);
3585
3586 wxPyEndAllowThreads(__tstate);
3587 if (PyErr_Occurred()) SWIG_fail;
3588 }
3589 {
3590 #if wxUSE_UNICODE
3591 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3592 #else
3593 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3594 #endif
3595 }
3596 return resultobj;
3597 fail:
3598 return NULL;
3599 }
3600
3601
3602 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3603 PyObject *resultobj;
3604 char *kwnames[] = {
3605 NULL
3606 };
3607
3608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3609 {
3610 if (!wxPyCheckForApp()) SWIG_fail;
3611 PyThreadState* __tstate = wxPyBeginAllowThreads();
3612 wxBell();
3613
3614 wxPyEndAllowThreads(__tstate);
3615 if (PyErr_Occurred()) SWIG_fail;
3616 }
3617 Py_INCREF(Py_None); resultobj = Py_None;
3618 return resultobj;
3619 fail:
3620 return NULL;
3621 }
3622
3623
3624 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3625 PyObject *resultobj;
3626 char *kwnames[] = {
3627 NULL
3628 };
3629
3630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3631 {
3632 if (!wxPyCheckForApp()) SWIG_fail;
3633 PyThreadState* __tstate = wxPyBeginAllowThreads();
3634 wxEndBusyCursor();
3635
3636 wxPyEndAllowThreads(__tstate);
3637 if (PyErr_Occurred()) SWIG_fail;
3638 }
3639 Py_INCREF(Py_None); resultobj = Py_None;
3640 return resultobj;
3641 fail:
3642 return NULL;
3643 }
3644
3645
3646 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3647 PyObject *resultobj;
3648 bool arg1 = (bool) true ;
3649 long result;
3650 PyObject * obj0 = 0 ;
3651 char *kwnames[] = {
3652 (char *) "resetTimer", NULL
3653 };
3654
3655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3656 if (obj0) {
3657 {
3658 arg1 = (bool)(SWIG_As_bool(obj0));
3659 if (SWIG_arg_fail(1)) SWIG_fail;
3660 }
3661 }
3662 {
3663 PyThreadState* __tstate = wxPyBeginAllowThreads();
3664 result = (long)wxGetElapsedTime(arg1);
3665
3666 wxPyEndAllowThreads(__tstate);
3667 if (PyErr_Occurred()) SWIG_fail;
3668 }
3669 {
3670 resultobj = SWIG_From_long((long)(result));
3671 }
3672 return resultobj;
3673 fail:
3674 return NULL;
3675 }
3676
3677
3678 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3679 PyObject *resultobj;
3680 int *arg1 = (int *) 0 ;
3681 int *arg2 = (int *) 0 ;
3682 int temp1 ;
3683 int res1 = 0 ;
3684 int temp2 ;
3685 int res2 = 0 ;
3686 char *kwnames[] = {
3687 NULL
3688 };
3689
3690 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3691 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3693 {
3694 if (!wxPyCheckForApp()) SWIG_fail;
3695 PyThreadState* __tstate = wxPyBeginAllowThreads();
3696 wxGetMousePosition(arg1,arg2);
3697
3698 wxPyEndAllowThreads(__tstate);
3699 if (PyErr_Occurred()) SWIG_fail;
3700 }
3701 Py_INCREF(Py_None); resultobj = Py_None;
3702 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3703 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3704 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3705 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3706 return resultobj;
3707 fail:
3708 return NULL;
3709 }
3710
3711
3712 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3713 PyObject *resultobj;
3714 bool result;
3715 char *kwnames[] = {
3716 NULL
3717 };
3718
3719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3720 {
3721 PyThreadState* __tstate = wxPyBeginAllowThreads();
3722 result = (bool)wxIsBusy();
3723
3724 wxPyEndAllowThreads(__tstate);
3725 if (PyErr_Occurred()) SWIG_fail;
3726 }
3727 {
3728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3729 }
3730 return resultobj;
3731 fail:
3732 return NULL;
3733 }
3734
3735
3736 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3737 PyObject *resultobj;
3738 wxString result;
3739 char *kwnames[] = {
3740 NULL
3741 };
3742
3743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3744 {
3745 PyThreadState* __tstate = wxPyBeginAllowThreads();
3746 result = wxNow();
3747
3748 wxPyEndAllowThreads(__tstate);
3749 if (PyErr_Occurred()) SWIG_fail;
3750 }
3751 {
3752 #if wxUSE_UNICODE
3753 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3754 #else
3755 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3756 #endif
3757 }
3758 return resultobj;
3759 fail:
3760 return NULL;
3761 }
3762
3763
3764 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3765 PyObject *resultobj;
3766 wxString const &arg1_defvalue = wxPyEmptyString ;
3767 wxString *arg1 = (wxString *) &arg1_defvalue ;
3768 bool result;
3769 bool temp1 = false ;
3770 PyObject * obj0 = 0 ;
3771 char *kwnames[] = {
3772 (char *) "command", NULL
3773 };
3774
3775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3776 if (obj0) {
3777 {
3778 arg1 = wxString_in_helper(obj0);
3779 if (arg1 == NULL) SWIG_fail;
3780 temp1 = true;
3781 }
3782 }
3783 {
3784 PyThreadState* __tstate = wxPyBeginAllowThreads();
3785 result = (bool)wxShell((wxString const &)*arg1);
3786
3787 wxPyEndAllowThreads(__tstate);
3788 if (PyErr_Occurred()) SWIG_fail;
3789 }
3790 {
3791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3792 }
3793 {
3794 if (temp1)
3795 delete arg1;
3796 }
3797 return resultobj;
3798 fail:
3799 {
3800 if (temp1)
3801 delete arg1;
3802 }
3803 return NULL;
3804 }
3805
3806
3807 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3808 PyObject *resultobj;
3809 char *kwnames[] = {
3810 NULL
3811 };
3812
3813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3814 {
3815 PyThreadState* __tstate = wxPyBeginAllowThreads();
3816 wxStartTimer();
3817
3818 wxPyEndAllowThreads(__tstate);
3819 if (PyErr_Occurred()) SWIG_fail;
3820 }
3821 Py_INCREF(Py_None); resultobj = Py_None;
3822 return resultobj;
3823 fail:
3824 return NULL;
3825 }
3826
3827
3828 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3829 PyObject *resultobj;
3830 int *arg1 = (int *) 0 ;
3831 int *arg2 = (int *) 0 ;
3832 int result;
3833 int temp1 ;
3834 int res1 = 0 ;
3835 int temp2 ;
3836 int res2 = 0 ;
3837 char *kwnames[] = {
3838 NULL
3839 };
3840
3841 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3842 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3844 {
3845 PyThreadState* __tstate = wxPyBeginAllowThreads();
3846 result = (int)wxGetOsVersion(arg1,arg2);
3847
3848 wxPyEndAllowThreads(__tstate);
3849 if (PyErr_Occurred()) SWIG_fail;
3850 }
3851 {
3852 resultobj = SWIG_From_int((int)(result));
3853 }
3854 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3855 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3856 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3857 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3858 return resultobj;
3859 fail:
3860 return NULL;
3861 }
3862
3863
3864 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3865 PyObject *resultobj;
3866 wxString result;
3867 char *kwnames[] = {
3868 NULL
3869 };
3870
3871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3872 {
3873 PyThreadState* __tstate = wxPyBeginAllowThreads();
3874 result = wxGetOsDescription();
3875
3876 wxPyEndAllowThreads(__tstate);
3877 if (PyErr_Occurred()) SWIG_fail;
3878 }
3879 {
3880 #if wxUSE_UNICODE
3881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3882 #else
3883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3884 #endif
3885 }
3886 return resultobj;
3887 fail:
3888 return NULL;
3889 }
3890
3891
3892 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3893 PyObject *resultobj;
3894 long result;
3895 char *kwnames[] = {
3896 NULL
3897 };
3898
3899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3900 {
3901 PyThreadState* __tstate = wxPyBeginAllowThreads();
3902 result = (long)wxGetFreeMemory();
3903
3904 wxPyEndAllowThreads(__tstate);
3905 if (PyErr_Occurred()) SWIG_fail;
3906 }
3907 {
3908 resultobj = SWIG_From_long((long)(result));
3909 }
3910 return resultobj;
3911 fail:
3912 return NULL;
3913 }
3914
3915
3916 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
3917 PyObject *resultobj;
3918 wxShutdownFlags arg1 ;
3919 bool result;
3920 PyObject * obj0 = 0 ;
3921 char *kwnames[] = {
3922 (char *) "wFlags", NULL
3923 };
3924
3925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
3926 {
3927 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
3928 if (SWIG_arg_fail(1)) SWIG_fail;
3929 }
3930 {
3931 if (!wxPyCheckForApp()) SWIG_fail;
3932 PyThreadState* __tstate = wxPyBeginAllowThreads();
3933 result = (bool)wxShutdown((wxShutdownFlags )arg1);
3934
3935 wxPyEndAllowThreads(__tstate);
3936 if (PyErr_Occurred()) SWIG_fail;
3937 }
3938 {
3939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3940 }
3941 return resultobj;
3942 fail:
3943 return NULL;
3944 }
3945
3946
3947 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
3948 PyObject *resultobj;
3949 int arg1 ;
3950 PyObject * obj0 = 0 ;
3951 char *kwnames[] = {
3952 (char *) "secs", NULL
3953 };
3954
3955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
3956 {
3957 arg1 = (int)(SWIG_As_int(obj0));
3958 if (SWIG_arg_fail(1)) SWIG_fail;
3959 }
3960 {
3961 PyThreadState* __tstate = wxPyBeginAllowThreads();
3962 wxSleep(arg1);
3963
3964 wxPyEndAllowThreads(__tstate);
3965 if (PyErr_Occurred()) SWIG_fail;
3966 }
3967 Py_INCREF(Py_None); resultobj = Py_None;
3968 return resultobj;
3969 fail:
3970 return NULL;
3971 }
3972
3973
3974 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3975 PyObject *resultobj;
3976 unsigned long arg1 ;
3977 PyObject * obj0 = 0 ;
3978 char *kwnames[] = {
3979 (char *) "milliseconds", NULL
3980 };
3981
3982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
3983 {
3984 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3985 if (SWIG_arg_fail(1)) SWIG_fail;
3986 }
3987 {
3988 PyThreadState* __tstate = wxPyBeginAllowThreads();
3989 wxMilliSleep(arg1);
3990
3991 wxPyEndAllowThreads(__tstate);
3992 if (PyErr_Occurred()) SWIG_fail;
3993 }
3994 Py_INCREF(Py_None); resultobj = Py_None;
3995 return resultobj;
3996 fail:
3997 return NULL;
3998 }
3999
4000
4001 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4002 PyObject *resultobj;
4003 unsigned long arg1 ;
4004 PyObject * obj0 = 0 ;
4005 char *kwnames[] = {
4006 (char *) "microseconds", NULL
4007 };
4008
4009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4010 {
4011 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4012 if (SWIG_arg_fail(1)) SWIG_fail;
4013 }
4014 {
4015 PyThreadState* __tstate = wxPyBeginAllowThreads();
4016 wxMicroSleep(arg1);
4017
4018 wxPyEndAllowThreads(__tstate);
4019 if (PyErr_Occurred()) SWIG_fail;
4020 }
4021 Py_INCREF(Py_None); resultobj = Py_None;
4022 return resultobj;
4023 fail:
4024 return NULL;
4025 }
4026
4027
4028 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4029 PyObject *resultobj;
4030 bool arg1 ;
4031 PyObject * obj0 = 0 ;
4032 char *kwnames[] = {
4033 (char *) "enable", NULL
4034 };
4035
4036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4037 {
4038 arg1 = (bool)(SWIG_As_bool(obj0));
4039 if (SWIG_arg_fail(1)) SWIG_fail;
4040 }
4041 {
4042 PyThreadState* __tstate = wxPyBeginAllowThreads();
4043 wxEnableTopLevelWindows(arg1);
4044
4045 wxPyEndAllowThreads(__tstate);
4046 if (PyErr_Occurred()) SWIG_fail;
4047 }
4048 Py_INCREF(Py_None); resultobj = Py_None;
4049 return resultobj;
4050 fail:
4051 return NULL;
4052 }
4053
4054
4055 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4056 PyObject *resultobj;
4057 wxString *arg1 = 0 ;
4058 wxString result;
4059 bool temp1 = false ;
4060 PyObject * obj0 = 0 ;
4061 char *kwnames[] = {
4062 (char *) "in", NULL
4063 };
4064
4065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4066 {
4067 arg1 = wxString_in_helper(obj0);
4068 if (arg1 == NULL) SWIG_fail;
4069 temp1 = true;
4070 }
4071 {
4072 PyThreadState* __tstate = wxPyBeginAllowThreads();
4073 result = wxStripMenuCodes((wxString const &)*arg1);
4074
4075 wxPyEndAllowThreads(__tstate);
4076 if (PyErr_Occurred()) SWIG_fail;
4077 }
4078 {
4079 #if wxUSE_UNICODE
4080 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4081 #else
4082 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4083 #endif
4084 }
4085 {
4086 if (temp1)
4087 delete arg1;
4088 }
4089 return resultobj;
4090 fail:
4091 {
4092 if (temp1)
4093 delete arg1;
4094 }
4095 return NULL;
4096 }
4097
4098
4099 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4100 PyObject *resultobj;
4101 wxString result;
4102 char *kwnames[] = {
4103 NULL
4104 };
4105
4106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4107 {
4108 PyThreadState* __tstate = wxPyBeginAllowThreads();
4109 result = wxGetEmailAddress();
4110
4111 wxPyEndAllowThreads(__tstate);
4112 if (PyErr_Occurred()) SWIG_fail;
4113 }
4114 {
4115 #if wxUSE_UNICODE
4116 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4117 #else
4118 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4119 #endif
4120 }
4121 return resultobj;
4122 fail:
4123 return NULL;
4124 }
4125
4126
4127 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4128 PyObject *resultobj;
4129 wxString result;
4130 char *kwnames[] = {
4131 NULL
4132 };
4133
4134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4135 {
4136 PyThreadState* __tstate = wxPyBeginAllowThreads();
4137 result = wxGetHostName();
4138
4139 wxPyEndAllowThreads(__tstate);
4140 if (PyErr_Occurred()) SWIG_fail;
4141 }
4142 {
4143 #if wxUSE_UNICODE
4144 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4145 #else
4146 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4147 #endif
4148 }
4149 return resultobj;
4150 fail:
4151 return NULL;
4152 }
4153
4154
4155 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4156 PyObject *resultobj;
4157 wxString result;
4158 char *kwnames[] = {
4159 NULL
4160 };
4161
4162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4163 {
4164 PyThreadState* __tstate = wxPyBeginAllowThreads();
4165 result = wxGetFullHostName();
4166
4167 wxPyEndAllowThreads(__tstate);
4168 if (PyErr_Occurred()) SWIG_fail;
4169 }
4170 {
4171 #if wxUSE_UNICODE
4172 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4173 #else
4174 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4175 #endif
4176 }
4177 return resultobj;
4178 fail:
4179 return NULL;
4180 }
4181
4182
4183 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4184 PyObject *resultobj;
4185 wxString result;
4186 char *kwnames[] = {
4187 NULL
4188 };
4189
4190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4191 {
4192 PyThreadState* __tstate = wxPyBeginAllowThreads();
4193 result = wxGetUserId();
4194
4195 wxPyEndAllowThreads(__tstate);
4196 if (PyErr_Occurred()) SWIG_fail;
4197 }
4198 {
4199 #if wxUSE_UNICODE
4200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4201 #else
4202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4203 #endif
4204 }
4205 return resultobj;
4206 fail:
4207 return NULL;
4208 }
4209
4210
4211 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4212 PyObject *resultobj;
4213 wxString result;
4214 char *kwnames[] = {
4215 NULL
4216 };
4217
4218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4219 {
4220 PyThreadState* __tstate = wxPyBeginAllowThreads();
4221 result = wxGetUserName();
4222
4223 wxPyEndAllowThreads(__tstate);
4224 if (PyErr_Occurred()) SWIG_fail;
4225 }
4226 {
4227 #if wxUSE_UNICODE
4228 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4229 #else
4230 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4231 #endif
4232 }
4233 return resultobj;
4234 fail:
4235 return NULL;
4236 }
4237
4238
4239 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4240 PyObject *resultobj;
4241 wxString result;
4242 char *kwnames[] = {
4243 NULL
4244 };
4245
4246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4247 {
4248 PyThreadState* __tstate = wxPyBeginAllowThreads();
4249 result = wxGetHomeDir();
4250
4251 wxPyEndAllowThreads(__tstate);
4252 if (PyErr_Occurred()) SWIG_fail;
4253 }
4254 {
4255 #if wxUSE_UNICODE
4256 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4257 #else
4258 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4259 #endif
4260 }
4261 return resultobj;
4262 fail:
4263 return NULL;
4264 }
4265
4266
4267 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4268 PyObject *resultobj;
4269 wxString const &arg1_defvalue = wxPyEmptyString ;
4270 wxString *arg1 = (wxString *) &arg1_defvalue ;
4271 wxString result;
4272 bool temp1 = false ;
4273 PyObject * obj0 = 0 ;
4274 char *kwnames[] = {
4275 (char *) "user", NULL
4276 };
4277
4278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4279 if (obj0) {
4280 {
4281 arg1 = wxString_in_helper(obj0);
4282 if (arg1 == NULL) SWIG_fail;
4283 temp1 = true;
4284 }
4285 }
4286 {
4287 PyThreadState* __tstate = wxPyBeginAllowThreads();
4288 result = wxGetUserHome((wxString const &)*arg1);
4289
4290 wxPyEndAllowThreads(__tstate);
4291 if (PyErr_Occurred()) SWIG_fail;
4292 }
4293 {
4294 #if wxUSE_UNICODE
4295 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4296 #else
4297 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4298 #endif
4299 }
4300 {
4301 if (temp1)
4302 delete arg1;
4303 }
4304 return resultobj;
4305 fail:
4306 {
4307 if (temp1)
4308 delete arg1;
4309 }
4310 return NULL;
4311 }
4312
4313
4314 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4315 PyObject *resultobj;
4316 unsigned long result;
4317 char *kwnames[] = {
4318 NULL
4319 };
4320
4321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4322 {
4323 PyThreadState* __tstate = wxPyBeginAllowThreads();
4324 result = (unsigned long)wxGetProcessId();
4325
4326 wxPyEndAllowThreads(__tstate);
4327 if (PyErr_Occurred()) SWIG_fail;
4328 }
4329 {
4330 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4331 }
4332 return resultobj;
4333 fail:
4334 return NULL;
4335 }
4336
4337
4338 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4339 PyObject *resultobj;
4340 char *kwnames[] = {
4341 NULL
4342 };
4343
4344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4345 {
4346 PyThreadState* __tstate = wxPyBeginAllowThreads();
4347 wxTrap();
4348
4349 wxPyEndAllowThreads(__tstate);
4350 if (PyErr_Occurred()) SWIG_fail;
4351 }
4352 Py_INCREF(Py_None); resultobj = Py_None;
4353 return resultobj;
4354 fail:
4355 return NULL;
4356 }
4357
4358
4359 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4360 PyObject *resultobj;
4361 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4362 wxString *arg1 = (wxString *) &arg1_defvalue ;
4363 wxString const &arg2_defvalue = wxPyEmptyString ;
4364 wxString *arg2 = (wxString *) &arg2_defvalue ;
4365 wxString const &arg3_defvalue = wxPyEmptyString ;
4366 wxString *arg3 = (wxString *) &arg3_defvalue ;
4367 wxString const &arg4_defvalue = wxPyEmptyString ;
4368 wxString *arg4 = (wxString *) &arg4_defvalue ;
4369 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4370 wxString *arg5 = (wxString *) &arg5_defvalue ;
4371 int arg6 = (int) 0 ;
4372 wxWindow *arg7 = (wxWindow *) NULL ;
4373 int arg8 = (int) -1 ;
4374 int arg9 = (int) -1 ;
4375 wxString result;
4376 bool temp1 = false ;
4377 bool temp2 = false ;
4378 bool temp3 = false ;
4379 bool temp4 = false ;
4380 bool temp5 = false ;
4381 PyObject * obj0 = 0 ;
4382 PyObject * obj1 = 0 ;
4383 PyObject * obj2 = 0 ;
4384 PyObject * obj3 = 0 ;
4385 PyObject * obj4 = 0 ;
4386 PyObject * obj5 = 0 ;
4387 PyObject * obj6 = 0 ;
4388 PyObject * obj7 = 0 ;
4389 PyObject * obj8 = 0 ;
4390 char *kwnames[] = {
4391 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4392 };
4393
4394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4395 if (obj0) {
4396 {
4397 arg1 = wxString_in_helper(obj0);
4398 if (arg1 == NULL) SWIG_fail;
4399 temp1 = true;
4400 }
4401 }
4402 if (obj1) {
4403 {
4404 arg2 = wxString_in_helper(obj1);
4405 if (arg2 == NULL) SWIG_fail;
4406 temp2 = true;
4407 }
4408 }
4409 if (obj2) {
4410 {
4411 arg3 = wxString_in_helper(obj2);
4412 if (arg3 == NULL) SWIG_fail;
4413 temp3 = true;
4414 }
4415 }
4416 if (obj3) {
4417 {
4418 arg4 = wxString_in_helper(obj3);
4419 if (arg4 == NULL) SWIG_fail;
4420 temp4 = true;
4421 }
4422 }
4423 if (obj4) {
4424 {
4425 arg5 = wxString_in_helper(obj4);
4426 if (arg5 == NULL) SWIG_fail;
4427 temp5 = true;
4428 }
4429 }
4430 if (obj5) {
4431 {
4432 arg6 = (int)(SWIG_As_int(obj5));
4433 if (SWIG_arg_fail(6)) SWIG_fail;
4434 }
4435 }
4436 if (obj6) {
4437 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4438 if (SWIG_arg_fail(7)) SWIG_fail;
4439 }
4440 if (obj7) {
4441 {
4442 arg8 = (int)(SWIG_As_int(obj7));
4443 if (SWIG_arg_fail(8)) SWIG_fail;
4444 }
4445 }
4446 if (obj8) {
4447 {
4448 arg9 = (int)(SWIG_As_int(obj8));
4449 if (SWIG_arg_fail(9)) SWIG_fail;
4450 }
4451 }
4452 {
4453 if (!wxPyCheckForApp()) SWIG_fail;
4454 PyThreadState* __tstate = wxPyBeginAllowThreads();
4455 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4456
4457 wxPyEndAllowThreads(__tstate);
4458 if (PyErr_Occurred()) SWIG_fail;
4459 }
4460 {
4461 #if wxUSE_UNICODE
4462 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4463 #else
4464 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4465 #endif
4466 }
4467 {
4468 if (temp1)
4469 delete arg1;
4470 }
4471 {
4472 if (temp2)
4473 delete arg2;
4474 }
4475 {
4476 if (temp3)
4477 delete arg3;
4478 }
4479 {
4480 if (temp4)
4481 delete arg4;
4482 }
4483 {
4484 if (temp5)
4485 delete arg5;
4486 }
4487 return resultobj;
4488 fail:
4489 {
4490 if (temp1)
4491 delete arg1;
4492 }
4493 {
4494 if (temp2)
4495 delete arg2;
4496 }
4497 {
4498 if (temp3)
4499 delete arg3;
4500 }
4501 {
4502 if (temp4)
4503 delete arg4;
4504 }
4505 {
4506 if (temp5)
4507 delete arg5;
4508 }
4509 return NULL;
4510 }
4511
4512
4513 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4514 PyObject *resultobj;
4515 wxString *arg1 = 0 ;
4516 wxString *arg2 = 0 ;
4517 wxString const &arg3_defvalue = wxPyEmptyString ;
4518 wxString *arg3 = (wxString *) &arg3_defvalue ;
4519 wxWindow *arg4 = (wxWindow *) NULL ;
4520 wxString result;
4521 bool temp1 = false ;
4522 bool temp2 = false ;
4523 bool temp3 = false ;
4524 PyObject * obj0 = 0 ;
4525 PyObject * obj1 = 0 ;
4526 PyObject * obj2 = 0 ;
4527 PyObject * obj3 = 0 ;
4528 char *kwnames[] = {
4529 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4530 };
4531
4532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4533 {
4534 arg1 = wxString_in_helper(obj0);
4535 if (arg1 == NULL) SWIG_fail;
4536 temp1 = true;
4537 }
4538 {
4539 arg2 = wxString_in_helper(obj1);
4540 if (arg2 == NULL) SWIG_fail;
4541 temp2 = true;
4542 }
4543 if (obj2) {
4544 {
4545 arg3 = wxString_in_helper(obj2);
4546 if (arg3 == NULL) SWIG_fail;
4547 temp3 = true;
4548 }
4549 }
4550 if (obj3) {
4551 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4552 if (SWIG_arg_fail(4)) SWIG_fail;
4553 }
4554 {
4555 if (!wxPyCheckForApp()) SWIG_fail;
4556 PyThreadState* __tstate = wxPyBeginAllowThreads();
4557 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4558
4559 wxPyEndAllowThreads(__tstate);
4560 if (PyErr_Occurred()) SWIG_fail;
4561 }
4562 {
4563 #if wxUSE_UNICODE
4564 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4565 #else
4566 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4567 #endif
4568 }
4569 {
4570 if (temp1)
4571 delete arg1;
4572 }
4573 {
4574 if (temp2)
4575 delete arg2;
4576 }
4577 {
4578 if (temp3)
4579 delete arg3;
4580 }
4581 return resultobj;
4582 fail:
4583 {
4584 if (temp1)
4585 delete arg1;
4586 }
4587 {
4588 if (temp2)
4589 delete arg2;
4590 }
4591 {
4592 if (temp3)
4593 delete arg3;
4594 }
4595 return NULL;
4596 }
4597
4598
4599 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4600 PyObject *resultobj;
4601 wxString *arg1 = 0 ;
4602 wxString *arg2 = 0 ;
4603 wxString const &arg3_defvalue = wxPyEmptyString ;
4604 wxString *arg3 = (wxString *) &arg3_defvalue ;
4605 wxWindow *arg4 = (wxWindow *) NULL ;
4606 wxString result;
4607 bool temp1 = false ;
4608 bool temp2 = false ;
4609 bool temp3 = false ;
4610 PyObject * obj0 = 0 ;
4611 PyObject * obj1 = 0 ;
4612 PyObject * obj2 = 0 ;
4613 PyObject * obj3 = 0 ;
4614 char *kwnames[] = {
4615 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4616 };
4617
4618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4619 {
4620 arg1 = wxString_in_helper(obj0);
4621 if (arg1 == NULL) SWIG_fail;
4622 temp1 = true;
4623 }
4624 {
4625 arg2 = wxString_in_helper(obj1);
4626 if (arg2 == NULL) SWIG_fail;
4627 temp2 = true;
4628 }
4629 if (obj2) {
4630 {
4631 arg3 = wxString_in_helper(obj2);
4632 if (arg3 == NULL) SWIG_fail;
4633 temp3 = true;
4634 }
4635 }
4636 if (obj3) {
4637 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4638 if (SWIG_arg_fail(4)) SWIG_fail;
4639 }
4640 {
4641 if (!wxPyCheckForApp()) SWIG_fail;
4642 PyThreadState* __tstate = wxPyBeginAllowThreads();
4643 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4644
4645 wxPyEndAllowThreads(__tstate);
4646 if (PyErr_Occurred()) SWIG_fail;
4647 }
4648 {
4649 #if wxUSE_UNICODE
4650 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4651 #else
4652 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4653 #endif
4654 }
4655 {
4656 if (temp1)
4657 delete arg1;
4658 }
4659 {
4660 if (temp2)
4661 delete arg2;
4662 }
4663 {
4664 if (temp3)
4665 delete arg3;
4666 }
4667 return resultobj;
4668 fail:
4669 {
4670 if (temp1)
4671 delete arg1;
4672 }
4673 {
4674 if (temp2)
4675 delete arg2;
4676 }
4677 {
4678 if (temp3)
4679 delete arg3;
4680 }
4681 return NULL;
4682 }
4683
4684
4685 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4686 PyObject *resultobj;
4687 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4688 wxString *arg1 = (wxString *) &arg1_defvalue ;
4689 wxString const &arg2_defvalue = wxPyEmptyString ;
4690 wxString *arg2 = (wxString *) &arg2_defvalue ;
4691 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4692 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4693 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4694 wxWindow *arg5 = (wxWindow *) NULL ;
4695 wxString result;
4696 bool temp1 = false ;
4697 bool temp2 = false ;
4698 wxPoint temp4 ;
4699 PyObject * obj0 = 0 ;
4700 PyObject * obj1 = 0 ;
4701 PyObject * obj2 = 0 ;
4702 PyObject * obj3 = 0 ;
4703 PyObject * obj4 = 0 ;
4704 char *kwnames[] = {
4705 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4706 };
4707
4708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4709 if (obj0) {
4710 {
4711 arg1 = wxString_in_helper(obj0);
4712 if (arg1 == NULL) SWIG_fail;
4713 temp1 = true;
4714 }
4715 }
4716 if (obj1) {
4717 {
4718 arg2 = wxString_in_helper(obj1);
4719 if (arg2 == NULL) SWIG_fail;
4720 temp2 = true;
4721 }
4722 }
4723 if (obj2) {
4724 {
4725 arg3 = (long)(SWIG_As_long(obj2));
4726 if (SWIG_arg_fail(3)) SWIG_fail;
4727 }
4728 }
4729 if (obj3) {
4730 {
4731 arg4 = &temp4;
4732 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4733 }
4734 }
4735 if (obj4) {
4736 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4737 if (SWIG_arg_fail(5)) SWIG_fail;
4738 }
4739 {
4740 if (!wxPyCheckForApp()) SWIG_fail;
4741 PyThreadState* __tstate = wxPyBeginAllowThreads();
4742 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4743
4744 wxPyEndAllowThreads(__tstate);
4745 if (PyErr_Occurred()) SWIG_fail;
4746 }
4747 {
4748 #if wxUSE_UNICODE
4749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4750 #else
4751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4752 #endif
4753 }
4754 {
4755 if (temp1)
4756 delete arg1;
4757 }
4758 {
4759 if (temp2)
4760 delete arg2;
4761 }
4762 return resultobj;
4763 fail:
4764 {
4765 if (temp1)
4766 delete arg1;
4767 }
4768 {
4769 if (temp2)
4770 delete arg2;
4771 }
4772 return NULL;
4773 }
4774
4775
4776 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4777 PyObject *resultobj;
4778 wxString *arg1 = 0 ;
4779 wxString const &arg2_defvalue = wxPyEmptyString ;
4780 wxString *arg2 = (wxString *) &arg2_defvalue ;
4781 wxString const &arg3_defvalue = wxPyEmptyString ;
4782 wxString *arg3 = (wxString *) &arg3_defvalue ;
4783 wxWindow *arg4 = (wxWindow *) NULL ;
4784 int arg5 = (int) -1 ;
4785 int arg6 = (int) -1 ;
4786 bool arg7 = (bool) true ;
4787 wxString result;
4788 bool temp1 = false ;
4789 bool temp2 = false ;
4790 bool temp3 = false ;
4791 PyObject * obj0 = 0 ;
4792 PyObject * obj1 = 0 ;
4793 PyObject * obj2 = 0 ;
4794 PyObject * obj3 = 0 ;
4795 PyObject * obj4 = 0 ;
4796 PyObject * obj5 = 0 ;
4797 PyObject * obj6 = 0 ;
4798 char *kwnames[] = {
4799 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4800 };
4801
4802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4803 {
4804 arg1 = wxString_in_helper(obj0);
4805 if (arg1 == NULL) SWIG_fail;
4806 temp1 = true;
4807 }
4808 if (obj1) {
4809 {
4810 arg2 = wxString_in_helper(obj1);
4811 if (arg2 == NULL) SWIG_fail;
4812 temp2 = true;
4813 }
4814 }
4815 if (obj2) {
4816 {
4817 arg3 = wxString_in_helper(obj2);
4818 if (arg3 == NULL) SWIG_fail;
4819 temp3 = true;
4820 }
4821 }
4822 if (obj3) {
4823 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4824 if (SWIG_arg_fail(4)) SWIG_fail;
4825 }
4826 if (obj4) {
4827 {
4828 arg5 = (int)(SWIG_As_int(obj4));
4829 if (SWIG_arg_fail(5)) SWIG_fail;
4830 }
4831 }
4832 if (obj5) {
4833 {
4834 arg6 = (int)(SWIG_As_int(obj5));
4835 if (SWIG_arg_fail(6)) SWIG_fail;
4836 }
4837 }
4838 if (obj6) {
4839 {
4840 arg7 = (bool)(SWIG_As_bool(obj6));
4841 if (SWIG_arg_fail(7)) SWIG_fail;
4842 }
4843 }
4844 {
4845 if (!wxPyCheckForApp()) SWIG_fail;
4846 PyThreadState* __tstate = wxPyBeginAllowThreads();
4847 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4848
4849 wxPyEndAllowThreads(__tstate);
4850 if (PyErr_Occurred()) SWIG_fail;
4851 }
4852 {
4853 #if wxUSE_UNICODE
4854 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4855 #else
4856 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4857 #endif
4858 }
4859 {
4860 if (temp1)
4861 delete arg1;
4862 }
4863 {
4864 if (temp2)
4865 delete arg2;
4866 }
4867 {
4868 if (temp3)
4869 delete arg3;
4870 }
4871 return resultobj;
4872 fail:
4873 {
4874 if (temp1)
4875 delete arg1;
4876 }
4877 {
4878 if (temp2)
4879 delete arg2;
4880 }
4881 {
4882 if (temp3)
4883 delete arg3;
4884 }
4885 return NULL;
4886 }
4887
4888
4889 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4890 PyObject *resultobj;
4891 wxString *arg1 = 0 ;
4892 wxString const &arg2_defvalue = wxPyEmptyString ;
4893 wxString *arg2 = (wxString *) &arg2_defvalue ;
4894 wxString const &arg3_defvalue = wxPyEmptyString ;
4895 wxString *arg3 = (wxString *) &arg3_defvalue ;
4896 wxWindow *arg4 = (wxWindow *) NULL ;
4897 wxString result;
4898 bool temp1 = false ;
4899 bool temp2 = false ;
4900 bool temp3 = false ;
4901 PyObject * obj0 = 0 ;
4902 PyObject * obj1 = 0 ;
4903 PyObject * obj2 = 0 ;
4904 PyObject * obj3 = 0 ;
4905 char *kwnames[] = {
4906 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4907 };
4908
4909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4910 {
4911 arg1 = wxString_in_helper(obj0);
4912 if (arg1 == NULL) SWIG_fail;
4913 temp1 = true;
4914 }
4915 if (obj1) {
4916 {
4917 arg2 = wxString_in_helper(obj1);
4918 if (arg2 == NULL) SWIG_fail;
4919 temp2 = true;
4920 }
4921 }
4922 if (obj2) {
4923 {
4924 arg3 = wxString_in_helper(obj2);
4925 if (arg3 == NULL) SWIG_fail;
4926 temp3 = true;
4927 }
4928 }
4929 if (obj3) {
4930 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4931 if (SWIG_arg_fail(4)) SWIG_fail;
4932 }
4933 {
4934 if (!wxPyCheckForApp()) SWIG_fail;
4935 PyThreadState* __tstate = wxPyBeginAllowThreads();
4936 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4937
4938 wxPyEndAllowThreads(__tstate);
4939 if (PyErr_Occurred()) SWIG_fail;
4940 }
4941 {
4942 #if wxUSE_UNICODE
4943 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4944 #else
4945 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4946 #endif
4947 }
4948 {
4949 if (temp1)
4950 delete arg1;
4951 }
4952 {
4953 if (temp2)
4954 delete arg2;
4955 }
4956 {
4957 if (temp3)
4958 delete arg3;
4959 }
4960 return resultobj;
4961 fail:
4962 {
4963 if (temp1)
4964 delete arg1;
4965 }
4966 {
4967 if (temp2)
4968 delete arg2;
4969 }
4970 {
4971 if (temp3)
4972 delete arg3;
4973 }
4974 return NULL;
4975 }
4976
4977
4978 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
4979 PyObject *resultobj;
4980 wxString *arg1 = 0 ;
4981 wxString *arg2 = 0 ;
4982 int arg3 ;
4983 wxString *arg4 = (wxString *) 0 ;
4984 wxWindow *arg5 = (wxWindow *) NULL ;
4985 int arg6 = (int) -1 ;
4986 int arg7 = (int) -1 ;
4987 bool arg8 = (bool) true ;
4988 int arg9 = (int) 150 ;
4989 int arg10 = (int) 200 ;
4990 wxString result;
4991 bool temp1 = false ;
4992 bool temp2 = false ;
4993 PyObject * obj0 = 0 ;
4994 PyObject * obj1 = 0 ;
4995 PyObject * obj2 = 0 ;
4996 PyObject * obj3 = 0 ;
4997 PyObject * obj4 = 0 ;
4998 PyObject * obj5 = 0 ;
4999 PyObject * obj6 = 0 ;
5000 PyObject * obj7 = 0 ;
5001 PyObject * obj8 = 0 ;
5002 char *kwnames[] = {
5003 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5004 };
5005
5006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5007 {
5008 arg1 = wxString_in_helper(obj0);
5009 if (arg1 == NULL) SWIG_fail;
5010 temp1 = true;
5011 }
5012 {
5013 arg2 = wxString_in_helper(obj1);
5014 if (arg2 == NULL) SWIG_fail;
5015 temp2 = true;
5016 }
5017 {
5018 arg3 = PyList_Size(obj2);
5019 arg4 = wxString_LIST_helper(obj2);
5020 if (arg4 == NULL) SWIG_fail;
5021 }
5022 if (obj3) {
5023 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5024 if (SWIG_arg_fail(5)) SWIG_fail;
5025 }
5026 if (obj4) {
5027 {
5028 arg6 = (int)(SWIG_As_int(obj4));
5029 if (SWIG_arg_fail(6)) SWIG_fail;
5030 }
5031 }
5032 if (obj5) {
5033 {
5034 arg7 = (int)(SWIG_As_int(obj5));
5035 if (SWIG_arg_fail(7)) SWIG_fail;
5036 }
5037 }
5038 if (obj6) {
5039 {
5040 arg8 = (bool)(SWIG_As_bool(obj6));
5041 if (SWIG_arg_fail(8)) SWIG_fail;
5042 }
5043 }
5044 if (obj7) {
5045 {
5046 arg9 = (int)(SWIG_As_int(obj7));
5047 if (SWIG_arg_fail(9)) SWIG_fail;
5048 }
5049 }
5050 if (obj8) {
5051 {
5052 arg10 = (int)(SWIG_As_int(obj8));
5053 if (SWIG_arg_fail(10)) SWIG_fail;
5054 }
5055 }
5056 {
5057 if (!wxPyCheckForApp()) SWIG_fail;
5058 PyThreadState* __tstate = wxPyBeginAllowThreads();
5059 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5060
5061 wxPyEndAllowThreads(__tstate);
5062 if (PyErr_Occurred()) SWIG_fail;
5063 }
5064 {
5065 #if wxUSE_UNICODE
5066 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5067 #else
5068 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5069 #endif
5070 }
5071 {
5072 if (temp1)
5073 delete arg1;
5074 }
5075 {
5076 if (temp2)
5077 delete arg2;
5078 }
5079 {
5080 if (arg4) delete [] arg4;
5081 }
5082 return resultobj;
5083 fail:
5084 {
5085 if (temp1)
5086 delete arg1;
5087 }
5088 {
5089 if (temp2)
5090 delete arg2;
5091 }
5092 {
5093 if (arg4) delete [] arg4;
5094 }
5095 return NULL;
5096 }
5097
5098
5099 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5100 PyObject *resultobj;
5101 wxString *arg1 = 0 ;
5102 wxString *arg2 = 0 ;
5103 int arg3 ;
5104 wxString *arg4 = (wxString *) 0 ;
5105 wxWindow *arg5 = (wxWindow *) NULL ;
5106 int arg6 = (int) -1 ;
5107 int arg7 = (int) -1 ;
5108 bool arg8 = (bool) true ;
5109 int arg9 = (int) 150 ;
5110 int arg10 = (int) 200 ;
5111 int result;
5112 bool temp1 = false ;
5113 bool temp2 = false ;
5114 PyObject * obj0 = 0 ;
5115 PyObject * obj1 = 0 ;
5116 PyObject * obj2 = 0 ;
5117 PyObject * obj3 = 0 ;
5118 PyObject * obj4 = 0 ;
5119 PyObject * obj5 = 0 ;
5120 PyObject * obj6 = 0 ;
5121 PyObject * obj7 = 0 ;
5122 PyObject * obj8 = 0 ;
5123 char *kwnames[] = {
5124 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5125 };
5126
5127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5128 {
5129 arg1 = wxString_in_helper(obj0);
5130 if (arg1 == NULL) SWIG_fail;
5131 temp1 = true;
5132 }
5133 {
5134 arg2 = wxString_in_helper(obj1);
5135 if (arg2 == NULL) SWIG_fail;
5136 temp2 = true;
5137 }
5138 {
5139 arg3 = PyList_Size(obj2);
5140 arg4 = wxString_LIST_helper(obj2);
5141 if (arg4 == NULL) SWIG_fail;
5142 }
5143 if (obj3) {
5144 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5145 if (SWIG_arg_fail(5)) SWIG_fail;
5146 }
5147 if (obj4) {
5148 {
5149 arg6 = (int)(SWIG_As_int(obj4));
5150 if (SWIG_arg_fail(6)) SWIG_fail;
5151 }
5152 }
5153 if (obj5) {
5154 {
5155 arg7 = (int)(SWIG_As_int(obj5));
5156 if (SWIG_arg_fail(7)) SWIG_fail;
5157 }
5158 }
5159 if (obj6) {
5160 {
5161 arg8 = (bool)(SWIG_As_bool(obj6));
5162 if (SWIG_arg_fail(8)) SWIG_fail;
5163 }
5164 }
5165 if (obj7) {
5166 {
5167 arg9 = (int)(SWIG_As_int(obj7));
5168 if (SWIG_arg_fail(9)) SWIG_fail;
5169 }
5170 }
5171 if (obj8) {
5172 {
5173 arg10 = (int)(SWIG_As_int(obj8));
5174 if (SWIG_arg_fail(10)) SWIG_fail;
5175 }
5176 }
5177 {
5178 if (!wxPyCheckForApp()) SWIG_fail;
5179 PyThreadState* __tstate = wxPyBeginAllowThreads();
5180 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5181
5182 wxPyEndAllowThreads(__tstate);
5183 if (PyErr_Occurred()) SWIG_fail;
5184 }
5185 {
5186 resultobj = SWIG_From_int((int)(result));
5187 }
5188 {
5189 if (temp1)
5190 delete arg1;
5191 }
5192 {
5193 if (temp2)
5194 delete arg2;
5195 }
5196 {
5197 if (arg4) delete [] arg4;
5198 }
5199 return resultobj;
5200 fail:
5201 {
5202 if (temp1)
5203 delete arg1;
5204 }
5205 {
5206 if (temp2)
5207 delete arg2;
5208 }
5209 {
5210 if (arg4) delete [] arg4;
5211 }
5212 return NULL;
5213 }
5214
5215
5216 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5217 PyObject *resultobj;
5218 wxString *arg1 = 0 ;
5219 wxString const &arg2_defvalue = wxPyEmptyString ;
5220 wxString *arg2 = (wxString *) &arg2_defvalue ;
5221 int arg3 = (int) wxOK|wxCENTRE ;
5222 wxWindow *arg4 = (wxWindow *) NULL ;
5223 int arg5 = (int) -1 ;
5224 int arg6 = (int) -1 ;
5225 int result;
5226 bool temp1 = false ;
5227 bool temp2 = false ;
5228 PyObject * obj0 = 0 ;
5229 PyObject * obj1 = 0 ;
5230 PyObject * obj2 = 0 ;
5231 PyObject * obj3 = 0 ;
5232 PyObject * obj4 = 0 ;
5233 PyObject * obj5 = 0 ;
5234 char *kwnames[] = {
5235 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5236 };
5237
5238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5239 {
5240 arg1 = wxString_in_helper(obj0);
5241 if (arg1 == NULL) SWIG_fail;
5242 temp1 = true;
5243 }
5244 if (obj1) {
5245 {
5246 arg2 = wxString_in_helper(obj1);
5247 if (arg2 == NULL) SWIG_fail;
5248 temp2 = true;
5249 }
5250 }
5251 if (obj2) {
5252 {
5253 arg3 = (int)(SWIG_As_int(obj2));
5254 if (SWIG_arg_fail(3)) SWIG_fail;
5255 }
5256 }
5257 if (obj3) {
5258 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5259 if (SWIG_arg_fail(4)) SWIG_fail;
5260 }
5261 if (obj4) {
5262 {
5263 arg5 = (int)(SWIG_As_int(obj4));
5264 if (SWIG_arg_fail(5)) SWIG_fail;
5265 }
5266 }
5267 if (obj5) {
5268 {
5269 arg6 = (int)(SWIG_As_int(obj5));
5270 if (SWIG_arg_fail(6)) SWIG_fail;
5271 }
5272 }
5273 {
5274 if (!wxPyCheckForApp()) SWIG_fail;
5275 PyThreadState* __tstate = wxPyBeginAllowThreads();
5276 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5277
5278 wxPyEndAllowThreads(__tstate);
5279 if (PyErr_Occurred()) SWIG_fail;
5280 }
5281 {
5282 resultobj = SWIG_From_int((int)(result));
5283 }
5284 {
5285 if (temp1)
5286 delete arg1;
5287 }
5288 {
5289 if (temp2)
5290 delete arg2;
5291 }
5292 return resultobj;
5293 fail:
5294 {
5295 if (temp1)
5296 delete arg1;
5297 }
5298 {
5299 if (temp2)
5300 delete arg2;
5301 }
5302 return NULL;
5303 }
5304
5305
5306 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5307 PyObject *resultobj;
5308 wxString *arg1 = 0 ;
5309 wxString *arg2 = 0 ;
5310 wxString *arg3 = 0 ;
5311 long arg4 ;
5312 long arg5 = (long) 0 ;
5313 long arg6 = (long) 100 ;
5314 wxWindow *arg7 = (wxWindow *) NULL ;
5315 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5316 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5317 long result;
5318 bool temp1 = false ;
5319 bool temp2 = false ;
5320 bool temp3 = false ;
5321 wxPoint temp8 ;
5322 PyObject * obj0 = 0 ;
5323 PyObject * obj1 = 0 ;
5324 PyObject * obj2 = 0 ;
5325 PyObject * obj3 = 0 ;
5326 PyObject * obj4 = 0 ;
5327 PyObject * obj5 = 0 ;
5328 PyObject * obj6 = 0 ;
5329 PyObject * obj7 = 0 ;
5330 char *kwnames[] = {
5331 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5332 };
5333
5334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5335 {
5336 arg1 = wxString_in_helper(obj0);
5337 if (arg1 == NULL) SWIG_fail;
5338 temp1 = true;
5339 }
5340 {
5341 arg2 = wxString_in_helper(obj1);
5342 if (arg2 == NULL) SWIG_fail;
5343 temp2 = true;
5344 }
5345 {
5346 arg3 = wxString_in_helper(obj2);
5347 if (arg3 == NULL) SWIG_fail;
5348 temp3 = true;
5349 }
5350 {
5351 arg4 = (long)(SWIG_As_long(obj3));
5352 if (SWIG_arg_fail(4)) SWIG_fail;
5353 }
5354 if (obj4) {
5355 {
5356 arg5 = (long)(SWIG_As_long(obj4));
5357 if (SWIG_arg_fail(5)) SWIG_fail;
5358 }
5359 }
5360 if (obj5) {
5361 {
5362 arg6 = (long)(SWIG_As_long(obj5));
5363 if (SWIG_arg_fail(6)) SWIG_fail;
5364 }
5365 }
5366 if (obj6) {
5367 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5368 if (SWIG_arg_fail(7)) SWIG_fail;
5369 }
5370 if (obj7) {
5371 {
5372 arg8 = &temp8;
5373 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5374 }
5375 }
5376 {
5377 if (!wxPyCheckForApp()) SWIG_fail;
5378 PyThreadState* __tstate = wxPyBeginAllowThreads();
5379 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5380
5381 wxPyEndAllowThreads(__tstate);
5382 if (PyErr_Occurred()) SWIG_fail;
5383 }
5384 {
5385 resultobj = SWIG_From_long((long)(result));
5386 }
5387 {
5388 if (temp1)
5389 delete arg1;
5390 }
5391 {
5392 if (temp2)
5393 delete arg2;
5394 }
5395 {
5396 if (temp3)
5397 delete arg3;
5398 }
5399 return resultobj;
5400 fail:
5401 {
5402 if (temp1)
5403 delete arg1;
5404 }
5405 {
5406 if (temp2)
5407 delete arg2;
5408 }
5409 {
5410 if (temp3)
5411 delete arg3;
5412 }
5413 return NULL;
5414 }
5415
5416
5417 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5418 PyObject *resultobj;
5419 bool result;
5420 char *kwnames[] = {
5421 NULL
5422 };
5423
5424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5425 {
5426 if (!wxPyCheckForApp()) SWIG_fail;
5427 PyThreadState* __tstate = wxPyBeginAllowThreads();
5428 result = (bool)wxColourDisplay();
5429
5430 wxPyEndAllowThreads(__tstate);
5431 if (PyErr_Occurred()) SWIG_fail;
5432 }
5433 {
5434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5435 }
5436 return resultobj;
5437 fail:
5438 return NULL;
5439 }
5440
5441
5442 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5443 PyObject *resultobj;
5444 int result;
5445 char *kwnames[] = {
5446 NULL
5447 };
5448
5449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5450 {
5451 if (!wxPyCheckForApp()) SWIG_fail;
5452 PyThreadState* __tstate = wxPyBeginAllowThreads();
5453 result = (int)wxDisplayDepth();
5454
5455 wxPyEndAllowThreads(__tstate);
5456 if (PyErr_Occurred()) SWIG_fail;
5457 }
5458 {
5459 resultobj = SWIG_From_int((int)(result));
5460 }
5461 return resultobj;
5462 fail:
5463 return NULL;
5464 }
5465
5466
5467 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5468 PyObject *resultobj;
5469 int result;
5470 char *kwnames[] = {
5471 NULL
5472 };
5473
5474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5475 {
5476 if (!wxPyCheckForApp()) SWIG_fail;
5477 PyThreadState* __tstate = wxPyBeginAllowThreads();
5478 result = (int)wxGetDisplayDepth();
5479
5480 wxPyEndAllowThreads(__tstate);
5481 if (PyErr_Occurred()) SWIG_fail;
5482 }
5483 {
5484 resultobj = SWIG_From_int((int)(result));
5485 }
5486 return resultobj;
5487 fail:
5488 return NULL;
5489 }
5490
5491
5492 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5493 PyObject *resultobj;
5494 int *arg1 = (int *) 0 ;
5495 int *arg2 = (int *) 0 ;
5496 int temp1 ;
5497 int res1 = 0 ;
5498 int temp2 ;
5499 int res2 = 0 ;
5500 char *kwnames[] = {
5501 NULL
5502 };
5503
5504 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5505 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5507 {
5508 if (!wxPyCheckForApp()) SWIG_fail;
5509 PyThreadState* __tstate = wxPyBeginAllowThreads();
5510 wxDisplaySize(arg1,arg2);
5511
5512 wxPyEndAllowThreads(__tstate);
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 Py_INCREF(Py_None); resultobj = Py_None;
5516 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5517 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5518 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5519 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5520 return resultobj;
5521 fail:
5522 return NULL;
5523 }
5524
5525
5526 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5527 PyObject *resultobj;
5528 wxSize result;
5529 char *kwnames[] = {
5530 NULL
5531 };
5532
5533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5534 {
5535 if (!wxPyCheckForApp()) SWIG_fail;
5536 PyThreadState* __tstate = wxPyBeginAllowThreads();
5537 result = wxGetDisplaySize();
5538
5539 wxPyEndAllowThreads(__tstate);
5540 if (PyErr_Occurred()) SWIG_fail;
5541 }
5542 {
5543 wxSize * resultptr;
5544 resultptr = new wxSize((wxSize &)(result));
5545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5546 }
5547 return resultobj;
5548 fail:
5549 return NULL;
5550 }
5551
5552
5553 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5554 PyObject *resultobj;
5555 int *arg1 = (int *) 0 ;
5556 int *arg2 = (int *) 0 ;
5557 int temp1 ;
5558 int res1 = 0 ;
5559 int temp2 ;
5560 int res2 = 0 ;
5561 char *kwnames[] = {
5562 NULL
5563 };
5564
5565 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5566 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5568 {
5569 if (!wxPyCheckForApp()) SWIG_fail;
5570 PyThreadState* __tstate = wxPyBeginAllowThreads();
5571 wxDisplaySizeMM(arg1,arg2);
5572
5573 wxPyEndAllowThreads(__tstate);
5574 if (PyErr_Occurred()) SWIG_fail;
5575 }
5576 Py_INCREF(Py_None); resultobj = Py_None;
5577 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5578 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5579 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5580 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5581 return resultobj;
5582 fail:
5583 return NULL;
5584 }
5585
5586
5587 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5588 PyObject *resultobj;
5589 wxSize result;
5590 char *kwnames[] = {
5591 NULL
5592 };
5593
5594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5595 {
5596 if (!wxPyCheckForApp()) SWIG_fail;
5597 PyThreadState* __tstate = wxPyBeginAllowThreads();
5598 result = wxGetDisplaySizeMM();
5599
5600 wxPyEndAllowThreads(__tstate);
5601 if (PyErr_Occurred()) SWIG_fail;
5602 }
5603 {
5604 wxSize * resultptr;
5605 resultptr = new wxSize((wxSize &)(result));
5606 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5607 }
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5615 PyObject *resultobj;
5616 int *arg1 = (int *) 0 ;
5617 int *arg2 = (int *) 0 ;
5618 int *arg3 = (int *) 0 ;
5619 int *arg4 = (int *) 0 ;
5620 int temp1 ;
5621 int res1 = 0 ;
5622 int temp2 ;
5623 int res2 = 0 ;
5624 int temp3 ;
5625 int res3 = 0 ;
5626 int temp4 ;
5627 int res4 = 0 ;
5628 char *kwnames[] = {
5629 NULL
5630 };
5631
5632 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5633 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5634 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5635 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5637 {
5638 if (!wxPyCheckForApp()) SWIG_fail;
5639 PyThreadState* __tstate = wxPyBeginAllowThreads();
5640 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5641
5642 wxPyEndAllowThreads(__tstate);
5643 if (PyErr_Occurred()) SWIG_fail;
5644 }
5645 Py_INCREF(Py_None); resultobj = Py_None;
5646 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5647 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5648 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5649 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5650 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5651 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5652 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5653 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5654 return resultobj;
5655 fail:
5656 return NULL;
5657 }
5658
5659
5660 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5661 PyObject *resultobj;
5662 wxRect result;
5663 char *kwnames[] = {
5664 NULL
5665 };
5666
5667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5668 {
5669 if (!wxPyCheckForApp()) SWIG_fail;
5670 PyThreadState* __tstate = wxPyBeginAllowThreads();
5671 result = wxGetClientDisplayRect();
5672
5673 wxPyEndAllowThreads(__tstate);
5674 if (PyErr_Occurred()) SWIG_fail;
5675 }
5676 {
5677 wxRect * resultptr;
5678 resultptr = new wxRect((wxRect &)(result));
5679 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5680 }
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5688 PyObject *resultobj;
5689 wxCursor *arg1 = 0 ;
5690 PyObject * obj0 = 0 ;
5691 char *kwnames[] = {
5692 (char *) "cursor", NULL
5693 };
5694
5695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5696 {
5697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5698 if (SWIG_arg_fail(1)) SWIG_fail;
5699 if (arg1 == NULL) {
5700 SWIG_null_ref("wxCursor");
5701 }
5702 if (SWIG_arg_fail(1)) SWIG_fail;
5703 }
5704 {
5705 if (!wxPyCheckForApp()) SWIG_fail;
5706 PyThreadState* __tstate = wxPyBeginAllowThreads();
5707 wxSetCursor(*arg1);
5708
5709 wxPyEndAllowThreads(__tstate);
5710 if (PyErr_Occurred()) SWIG_fail;
5711 }
5712 Py_INCREF(Py_None); resultobj = Py_None;
5713 return resultobj;
5714 fail:
5715 return NULL;
5716 }
5717
5718
5719 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5720 PyObject *resultobj;
5721 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5722 PyObject * obj0 = 0 ;
5723 char *kwnames[] = {
5724 (char *) "cursor", NULL
5725 };
5726
5727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5728 if (obj0) {
5729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5730 if (SWIG_arg_fail(1)) SWIG_fail;
5731 }
5732 {
5733 if (!wxPyCheckForApp()) SWIG_fail;
5734 PyThreadState* __tstate = wxPyBeginAllowThreads();
5735 wxBeginBusyCursor(arg1);
5736
5737 wxPyEndAllowThreads(__tstate);
5738 if (PyErr_Occurred()) SWIG_fail;
5739 }
5740 Py_INCREF(Py_None); resultobj = Py_None;
5741 return resultobj;
5742 fail:
5743 return NULL;
5744 }
5745
5746
5747 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5748 PyObject *resultobj;
5749 wxWindow *result;
5750 char *kwnames[] = {
5751 NULL
5752 };
5753
5754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5755 {
5756 if (!wxPyCheckForApp()) SWIG_fail;
5757 PyThreadState* __tstate = wxPyBeginAllowThreads();
5758 result = (wxWindow *)wxGetActiveWindow();
5759
5760 wxPyEndAllowThreads(__tstate);
5761 if (PyErr_Occurred()) SWIG_fail;
5762 }
5763 {
5764 resultobj = wxPyMake_wxObject(result, 0);
5765 }
5766 return resultobj;
5767 fail:
5768 return NULL;
5769 }
5770
5771
5772 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5773 PyObject *resultobj;
5774 wxPoint *arg1 = 0 ;
5775 wxWindow *result;
5776 wxPoint temp1 ;
5777 PyObject * obj0 = 0 ;
5778 char *kwnames[] = {
5779 (char *) "pt", NULL
5780 };
5781
5782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5783 {
5784 arg1 = &temp1;
5785 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5786 }
5787 {
5788 if (!wxPyCheckForApp()) SWIG_fail;
5789 PyThreadState* __tstate = wxPyBeginAllowThreads();
5790 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5791
5792 wxPyEndAllowThreads(__tstate);
5793 if (PyErr_Occurred()) SWIG_fail;
5794 }
5795 {
5796 resultobj = wxPyMake_wxObject(result, 0);
5797 }
5798 return resultobj;
5799 fail:
5800 return NULL;
5801 }
5802
5803
5804 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5805 PyObject *resultobj;
5806 wxPoint *arg1 = 0 ;
5807 wxWindow *result;
5808 wxPoint temp1 ;
5809 PyObject * obj0 = 0 ;
5810 char *kwnames[] = {
5811 (char *) "pt", NULL
5812 };
5813
5814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5815 {
5816 arg1 = &temp1;
5817 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5818 }
5819 {
5820 if (!wxPyCheckForApp()) SWIG_fail;
5821 PyThreadState* __tstate = wxPyBeginAllowThreads();
5822 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5823
5824 wxPyEndAllowThreads(__tstate);
5825 if (PyErr_Occurred()) SWIG_fail;
5826 }
5827 {
5828 resultobj = wxPyMake_wxObject(result, 0);
5829 }
5830 return resultobj;
5831 fail:
5832 return NULL;
5833 }
5834
5835
5836 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5837 PyObject *resultobj;
5838 wxWindow *arg1 = (wxWindow *) 0 ;
5839 wxWindow *result;
5840 PyObject * obj0 = 0 ;
5841 char *kwnames[] = {
5842 (char *) "win", NULL
5843 };
5844
5845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5847 if (SWIG_arg_fail(1)) SWIG_fail;
5848 {
5849 if (!wxPyCheckForApp()) SWIG_fail;
5850 PyThreadState* __tstate = wxPyBeginAllowThreads();
5851 result = (wxWindow *)wxGetTopLevelParent(arg1);
5852
5853 wxPyEndAllowThreads(__tstate);
5854 if (PyErr_Occurred()) SWIG_fail;
5855 }
5856 {
5857 resultobj = wxPyMake_wxObject(result, 0);
5858 }
5859 return resultobj;
5860 fail:
5861 return NULL;
5862 }
5863
5864
5865 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj;
5867 wxKeyCode arg1 ;
5868 bool result;
5869 PyObject * obj0 = 0 ;
5870 char *kwnames[] = {
5871 (char *) "key", NULL
5872 };
5873
5874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5875 {
5876 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5877 if (SWIG_arg_fail(1)) SWIG_fail;
5878 }
5879 {
5880 if (!wxPyCheckForApp()) SWIG_fail;
5881 PyThreadState* __tstate = wxPyBeginAllowThreads();
5882 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5883
5884 wxPyEndAllowThreads(__tstate);
5885 if (PyErr_Occurred()) SWIG_fail;
5886 }
5887 {
5888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5889 }
5890 return resultobj;
5891 fail:
5892 return NULL;
5893 }
5894
5895
5896 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5897 PyObject *resultobj;
5898 char *kwnames[] = {
5899 NULL
5900 };
5901
5902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5903 {
5904 if (!wxPyCheckForApp()) SWIG_fail;
5905 PyThreadState* __tstate = wxPyBeginAllowThreads();
5906 wxWakeUpMainThread();
5907
5908 wxPyEndAllowThreads(__tstate);
5909 if (PyErr_Occurred()) SWIG_fail;
5910 }
5911 Py_INCREF(Py_None); resultobj = Py_None;
5912 return resultobj;
5913 fail:
5914 return NULL;
5915 }
5916
5917
5918 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
5919 PyObject *resultobj;
5920 char *kwnames[] = {
5921 NULL
5922 };
5923
5924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
5925 {
5926 if (!wxPyCheckForApp()) SWIG_fail;
5927 PyThreadState* __tstate = wxPyBeginAllowThreads();
5928 wxMutexGuiEnter();
5929
5930 wxPyEndAllowThreads(__tstate);
5931 if (PyErr_Occurred()) SWIG_fail;
5932 }
5933 Py_INCREF(Py_None); resultobj = Py_None;
5934 return resultobj;
5935 fail:
5936 return NULL;
5937 }
5938
5939
5940 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
5941 PyObject *resultobj;
5942 char *kwnames[] = {
5943 NULL
5944 };
5945
5946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
5947 {
5948 if (!wxPyCheckForApp()) SWIG_fail;
5949 PyThreadState* __tstate = wxPyBeginAllowThreads();
5950 wxMutexGuiLeave();
5951
5952 wxPyEndAllowThreads(__tstate);
5953 if (PyErr_Occurred()) SWIG_fail;
5954 }
5955 Py_INCREF(Py_None); resultobj = Py_None;
5956 return resultobj;
5957 fail:
5958 return NULL;
5959 }
5960
5961
5962 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5963 PyObject *resultobj;
5964 wxMutexGuiLocker *result;
5965 char *kwnames[] = {
5966 NULL
5967 };
5968
5969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
5970 {
5971 if (!wxPyCheckForApp()) SWIG_fail;
5972 PyThreadState* __tstate = wxPyBeginAllowThreads();
5973 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
5974
5975 wxPyEndAllowThreads(__tstate);
5976 if (PyErr_Occurred()) SWIG_fail;
5977 }
5978 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
5979 return resultobj;
5980 fail:
5981 return NULL;
5982 }
5983
5984
5985 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5986 PyObject *resultobj;
5987 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
5988 PyObject * obj0 = 0 ;
5989 char *kwnames[] = {
5990 (char *) "self", NULL
5991 };
5992
5993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
5994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
5995 if (SWIG_arg_fail(1)) SWIG_fail;
5996 {
5997 PyThreadState* __tstate = wxPyBeginAllowThreads();
5998 delete arg1;
5999
6000 wxPyEndAllowThreads(__tstate);
6001 if (PyErr_Occurred()) SWIG_fail;
6002 }
6003 Py_INCREF(Py_None); resultobj = Py_None;
6004 return resultobj;
6005 fail:
6006 return NULL;
6007 }
6008
6009
6010 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6011 PyObject *obj;
6012 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6013 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6014 Py_INCREF(obj);
6015 return Py_BuildValue((char *)"");
6016 }
6017 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6018 PyObject *resultobj;
6019 bool result;
6020 char *kwnames[] = {
6021 NULL
6022 };
6023
6024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6025 {
6026 PyThreadState* __tstate = wxPyBeginAllowThreads();
6027 result = (bool)wxThread_IsMain();
6028
6029 wxPyEndAllowThreads(__tstate);
6030 if (PyErr_Occurred()) SWIG_fail;
6031 }
6032 {
6033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6034 }
6035 return resultobj;
6036 fail:
6037 return NULL;
6038 }
6039
6040
6041 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6042 PyObject *resultobj;
6043 wxString *arg1 = 0 ;
6044 wxToolTip *result;
6045 bool temp1 = false ;
6046 PyObject * obj0 = 0 ;
6047 char *kwnames[] = {
6048 (char *) "tip", NULL
6049 };
6050
6051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6052 {
6053 arg1 = wxString_in_helper(obj0);
6054 if (arg1 == NULL) SWIG_fail;
6055 temp1 = true;
6056 }
6057 {
6058 if (!wxPyCheckForApp()) SWIG_fail;
6059 PyThreadState* __tstate = wxPyBeginAllowThreads();
6060 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6061
6062 wxPyEndAllowThreads(__tstate);
6063 if (PyErr_Occurred()) SWIG_fail;
6064 }
6065 {
6066 resultobj = wxPyMake_wxObject(result, 1);
6067 }
6068 {
6069 if (temp1)
6070 delete arg1;
6071 }
6072 return resultobj;
6073 fail:
6074 {
6075 if (temp1)
6076 delete arg1;
6077 }
6078 return NULL;
6079 }
6080
6081
6082 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6083 PyObject *resultobj;
6084 wxToolTip *arg1 = (wxToolTip *) 0 ;
6085 wxString *arg2 = 0 ;
6086 bool temp2 = false ;
6087 PyObject * obj0 = 0 ;
6088 PyObject * obj1 = 0 ;
6089 char *kwnames[] = {
6090 (char *) "self",(char *) "tip", NULL
6091 };
6092
6093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6095 if (SWIG_arg_fail(1)) SWIG_fail;
6096 {
6097 arg2 = wxString_in_helper(obj1);
6098 if (arg2 == NULL) SWIG_fail;
6099 temp2 = true;
6100 }
6101 {
6102 PyThreadState* __tstate = wxPyBeginAllowThreads();
6103 (arg1)->SetTip((wxString const &)*arg2);
6104
6105 wxPyEndAllowThreads(__tstate);
6106 if (PyErr_Occurred()) SWIG_fail;
6107 }
6108 Py_INCREF(Py_None); resultobj = Py_None;
6109 {
6110 if (temp2)
6111 delete arg2;
6112 }
6113 return resultobj;
6114 fail:
6115 {
6116 if (temp2)
6117 delete arg2;
6118 }
6119 return NULL;
6120 }
6121
6122
6123 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6124 PyObject *resultobj;
6125 wxToolTip *arg1 = (wxToolTip *) 0 ;
6126 wxString result;
6127 PyObject * obj0 = 0 ;
6128 char *kwnames[] = {
6129 (char *) "self", NULL
6130 };
6131
6132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6134 if (SWIG_arg_fail(1)) SWIG_fail;
6135 {
6136 PyThreadState* __tstate = wxPyBeginAllowThreads();
6137 result = (arg1)->GetTip();
6138
6139 wxPyEndAllowThreads(__tstate);
6140 if (PyErr_Occurred()) SWIG_fail;
6141 }
6142 {
6143 #if wxUSE_UNICODE
6144 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6145 #else
6146 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6147 #endif
6148 }
6149 return resultobj;
6150 fail:
6151 return NULL;
6152 }
6153
6154
6155 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6156 PyObject *resultobj;
6157 wxToolTip *arg1 = (wxToolTip *) 0 ;
6158 wxWindow *result;
6159 PyObject * obj0 = 0 ;
6160 char *kwnames[] = {
6161 (char *) "self", NULL
6162 };
6163
6164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6166 if (SWIG_arg_fail(1)) SWIG_fail;
6167 {
6168 PyThreadState* __tstate = wxPyBeginAllowThreads();
6169 result = (wxWindow *)(arg1)->GetWindow();
6170
6171 wxPyEndAllowThreads(__tstate);
6172 if (PyErr_Occurred()) SWIG_fail;
6173 }
6174 {
6175 resultobj = wxPyMake_wxObject(result, 0);
6176 }
6177 return resultobj;
6178 fail:
6179 return NULL;
6180 }
6181
6182
6183 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6184 PyObject *resultobj;
6185 bool arg1 ;
6186 PyObject * obj0 = 0 ;
6187 char *kwnames[] = {
6188 (char *) "flag", NULL
6189 };
6190
6191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6192 {
6193 arg1 = (bool)(SWIG_As_bool(obj0));
6194 if (SWIG_arg_fail(1)) SWIG_fail;
6195 }
6196 {
6197 PyThreadState* __tstate = wxPyBeginAllowThreads();
6198 wxToolTip::Enable(arg1);
6199
6200 wxPyEndAllowThreads(__tstate);
6201 if (PyErr_Occurred()) SWIG_fail;
6202 }
6203 Py_INCREF(Py_None); resultobj = Py_None;
6204 return resultobj;
6205 fail:
6206 return NULL;
6207 }
6208
6209
6210 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6211 PyObject *resultobj;
6212 long arg1 ;
6213 PyObject * obj0 = 0 ;
6214 char *kwnames[] = {
6215 (char *) "milliseconds", NULL
6216 };
6217
6218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6219 {
6220 arg1 = (long)(SWIG_As_long(obj0));
6221 if (SWIG_arg_fail(1)) SWIG_fail;
6222 }
6223 {
6224 PyThreadState* __tstate = wxPyBeginAllowThreads();
6225 wxToolTip::SetDelay(arg1);
6226
6227 wxPyEndAllowThreads(__tstate);
6228 if (PyErr_Occurred()) SWIG_fail;
6229 }
6230 Py_INCREF(Py_None); resultobj = Py_None;
6231 return resultobj;
6232 fail:
6233 return NULL;
6234 }
6235
6236
6237 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6238 PyObject *obj;
6239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6240 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6241 Py_INCREF(obj);
6242 return Py_BuildValue((char *)"");
6243 }
6244 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6245 PyObject *resultobj;
6246 wxWindow *arg1 = (wxWindow *) 0 ;
6247 wxSize *arg2 = 0 ;
6248 wxCaret *result;
6249 wxSize temp2 ;
6250 PyObject * obj0 = 0 ;
6251 PyObject * obj1 = 0 ;
6252 char *kwnames[] = {
6253 (char *) "window",(char *) "size", NULL
6254 };
6255
6256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6258 if (SWIG_arg_fail(1)) SWIG_fail;
6259 {
6260 arg2 = &temp2;
6261 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6262 }
6263 {
6264 if (!wxPyCheckForApp()) SWIG_fail;
6265 PyThreadState* __tstate = wxPyBeginAllowThreads();
6266 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6267
6268 wxPyEndAllowThreads(__tstate);
6269 if (PyErr_Occurred()) SWIG_fail;
6270 }
6271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6279 PyObject *resultobj;
6280 wxCaret *arg1 = (wxCaret *) 0 ;
6281 PyObject * obj0 = 0 ;
6282 char *kwnames[] = {
6283 (char *) "self", NULL
6284 };
6285
6286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6288 if (SWIG_arg_fail(1)) SWIG_fail;
6289 {
6290 PyThreadState* __tstate = wxPyBeginAllowThreads();
6291 wxCaret_Destroy(arg1);
6292
6293 wxPyEndAllowThreads(__tstate);
6294 if (PyErr_Occurred()) SWIG_fail;
6295 }
6296 Py_INCREF(Py_None); resultobj = Py_None;
6297 return resultobj;
6298 fail:
6299 return NULL;
6300 }
6301
6302
6303 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6304 PyObject *resultobj;
6305 wxCaret *arg1 = (wxCaret *) 0 ;
6306 bool result;
6307 PyObject * obj0 = 0 ;
6308 char *kwnames[] = {
6309 (char *) "self", NULL
6310 };
6311
6312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6314 if (SWIG_arg_fail(1)) SWIG_fail;
6315 {
6316 PyThreadState* __tstate = wxPyBeginAllowThreads();
6317 result = (bool)(arg1)->IsOk();
6318
6319 wxPyEndAllowThreads(__tstate);
6320 if (PyErr_Occurred()) SWIG_fail;
6321 }
6322 {
6323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6324 }
6325 return resultobj;
6326 fail:
6327 return NULL;
6328 }
6329
6330
6331 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6332 PyObject *resultobj;
6333 wxCaret *arg1 = (wxCaret *) 0 ;
6334 bool result;
6335 PyObject * obj0 = 0 ;
6336 char *kwnames[] = {
6337 (char *) "self", NULL
6338 };
6339
6340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6342 if (SWIG_arg_fail(1)) SWIG_fail;
6343 {
6344 PyThreadState* __tstate = wxPyBeginAllowThreads();
6345 result = (bool)(arg1)->IsVisible();
6346
6347 wxPyEndAllowThreads(__tstate);
6348 if (PyErr_Occurred()) SWIG_fail;
6349 }
6350 {
6351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6352 }
6353 return resultobj;
6354 fail:
6355 return NULL;
6356 }
6357
6358
6359 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6360 PyObject *resultobj;
6361 wxCaret *arg1 = (wxCaret *) 0 ;
6362 wxPoint result;
6363 PyObject * obj0 = 0 ;
6364 char *kwnames[] = {
6365 (char *) "self", NULL
6366 };
6367
6368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6370 if (SWIG_arg_fail(1)) SWIG_fail;
6371 {
6372 PyThreadState* __tstate = wxPyBeginAllowThreads();
6373 result = (arg1)->GetPosition();
6374
6375 wxPyEndAllowThreads(__tstate);
6376 if (PyErr_Occurred()) SWIG_fail;
6377 }
6378 {
6379 wxPoint * resultptr;
6380 resultptr = new wxPoint((wxPoint &)(result));
6381 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6382 }
6383 return resultobj;
6384 fail:
6385 return NULL;
6386 }
6387
6388
6389 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6390 PyObject *resultobj;
6391 wxCaret *arg1 = (wxCaret *) 0 ;
6392 int *arg2 = (int *) 0 ;
6393 int *arg3 = (int *) 0 ;
6394 int temp2 ;
6395 int res2 = 0 ;
6396 int temp3 ;
6397 int res3 = 0 ;
6398 PyObject * obj0 = 0 ;
6399 char *kwnames[] = {
6400 (char *) "self", NULL
6401 };
6402
6403 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6404 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6407 if (SWIG_arg_fail(1)) SWIG_fail;
6408 {
6409 PyThreadState* __tstate = wxPyBeginAllowThreads();
6410 (arg1)->GetPosition(arg2,arg3);
6411
6412 wxPyEndAllowThreads(__tstate);
6413 if (PyErr_Occurred()) SWIG_fail;
6414 }
6415 Py_INCREF(Py_None); resultobj = Py_None;
6416 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6417 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6418 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6419 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6420 return resultobj;
6421 fail:
6422 return NULL;
6423 }
6424
6425
6426 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6427 PyObject *resultobj;
6428 wxCaret *arg1 = (wxCaret *) 0 ;
6429 wxSize result;
6430 PyObject * obj0 = 0 ;
6431 char *kwnames[] = {
6432 (char *) "self", NULL
6433 };
6434
6435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6437 if (SWIG_arg_fail(1)) SWIG_fail;
6438 {
6439 PyThreadState* __tstate = wxPyBeginAllowThreads();
6440 result = (arg1)->GetSize();
6441
6442 wxPyEndAllowThreads(__tstate);
6443 if (PyErr_Occurred()) SWIG_fail;
6444 }
6445 {
6446 wxSize * resultptr;
6447 resultptr = new wxSize((wxSize &)(result));
6448 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6449 }
6450 return resultobj;
6451 fail:
6452 return NULL;
6453 }
6454
6455
6456 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6457 PyObject *resultobj;
6458 wxCaret *arg1 = (wxCaret *) 0 ;
6459 int *arg2 = (int *) 0 ;
6460 int *arg3 = (int *) 0 ;
6461 int temp2 ;
6462 int res2 = 0 ;
6463 int temp3 ;
6464 int res3 = 0 ;
6465 PyObject * obj0 = 0 ;
6466 char *kwnames[] = {
6467 (char *) "self", NULL
6468 };
6469
6470 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6471 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6474 if (SWIG_arg_fail(1)) SWIG_fail;
6475 {
6476 PyThreadState* __tstate = wxPyBeginAllowThreads();
6477 (arg1)->GetSize(arg2,arg3);
6478
6479 wxPyEndAllowThreads(__tstate);
6480 if (PyErr_Occurred()) SWIG_fail;
6481 }
6482 Py_INCREF(Py_None); resultobj = Py_None;
6483 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6484 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6485 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6486 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6487 return resultobj;
6488 fail:
6489 return NULL;
6490 }
6491
6492
6493 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6494 PyObject *resultobj;
6495 wxCaret *arg1 = (wxCaret *) 0 ;
6496 wxWindow *result;
6497 PyObject * obj0 = 0 ;
6498 char *kwnames[] = {
6499 (char *) "self", NULL
6500 };
6501
6502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6504 if (SWIG_arg_fail(1)) SWIG_fail;
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (wxWindow *)(arg1)->GetWindow();
6508
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 {
6513 resultobj = wxPyMake_wxObject(result, 0);
6514 }
6515 return resultobj;
6516 fail:
6517 return NULL;
6518 }
6519
6520
6521 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6522 PyObject *resultobj;
6523 wxCaret *arg1 = (wxCaret *) 0 ;
6524 int arg2 ;
6525 int arg3 ;
6526 PyObject * obj0 = 0 ;
6527 PyObject * obj1 = 0 ;
6528 PyObject * obj2 = 0 ;
6529 char *kwnames[] = {
6530 (char *) "self",(char *) "x",(char *) "y", NULL
6531 };
6532
6533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6535 if (SWIG_arg_fail(1)) SWIG_fail;
6536 {
6537 arg2 = (int)(SWIG_As_int(obj1));
6538 if (SWIG_arg_fail(2)) SWIG_fail;
6539 }
6540 {
6541 arg3 = (int)(SWIG_As_int(obj2));
6542 if (SWIG_arg_fail(3)) SWIG_fail;
6543 }
6544 {
6545 PyThreadState* __tstate = wxPyBeginAllowThreads();
6546 (arg1)->Move(arg2,arg3);
6547
6548 wxPyEndAllowThreads(__tstate);
6549 if (PyErr_Occurred()) SWIG_fail;
6550 }
6551 Py_INCREF(Py_None); resultobj = Py_None;
6552 return resultobj;
6553 fail:
6554 return NULL;
6555 }
6556
6557
6558 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6559 PyObject *resultobj;
6560 wxCaret *arg1 = (wxCaret *) 0 ;
6561 wxPoint *arg2 = 0 ;
6562 wxPoint temp2 ;
6563 PyObject * obj0 = 0 ;
6564 PyObject * obj1 = 0 ;
6565 char *kwnames[] = {
6566 (char *) "self",(char *) "pt", NULL
6567 };
6568
6569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6571 if (SWIG_arg_fail(1)) SWIG_fail;
6572 {
6573 arg2 = &temp2;
6574 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6575 }
6576 {
6577 PyThreadState* __tstate = wxPyBeginAllowThreads();
6578 (arg1)->Move((wxPoint const &)*arg2);
6579
6580 wxPyEndAllowThreads(__tstate);
6581 if (PyErr_Occurred()) SWIG_fail;
6582 }
6583 Py_INCREF(Py_None); resultobj = Py_None;
6584 return resultobj;
6585 fail:
6586 return NULL;
6587 }
6588
6589
6590 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6591 PyObject *resultobj;
6592 wxCaret *arg1 = (wxCaret *) 0 ;
6593 int arg2 ;
6594 int arg3 ;
6595 PyObject * obj0 = 0 ;
6596 PyObject * obj1 = 0 ;
6597 PyObject * obj2 = 0 ;
6598 char *kwnames[] = {
6599 (char *) "self",(char *) "width",(char *) "height", NULL
6600 };
6601
6602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6604 if (SWIG_arg_fail(1)) SWIG_fail;
6605 {
6606 arg2 = (int)(SWIG_As_int(obj1));
6607 if (SWIG_arg_fail(2)) SWIG_fail;
6608 }
6609 {
6610 arg3 = (int)(SWIG_As_int(obj2));
6611 if (SWIG_arg_fail(3)) SWIG_fail;
6612 }
6613 {
6614 PyThreadState* __tstate = wxPyBeginAllowThreads();
6615 (arg1)->SetSize(arg2,arg3);
6616
6617 wxPyEndAllowThreads(__tstate);
6618 if (PyErr_Occurred()) SWIG_fail;
6619 }
6620 Py_INCREF(Py_None); resultobj = Py_None;
6621 return resultobj;
6622 fail:
6623 return NULL;
6624 }
6625
6626
6627 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6628 PyObject *resultobj;
6629 wxCaret *arg1 = (wxCaret *) 0 ;
6630 wxSize *arg2 = 0 ;
6631 wxSize temp2 ;
6632 PyObject * obj0 = 0 ;
6633 PyObject * obj1 = 0 ;
6634 char *kwnames[] = {
6635 (char *) "self",(char *) "size", NULL
6636 };
6637
6638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6640 if (SWIG_arg_fail(1)) SWIG_fail;
6641 {
6642 arg2 = &temp2;
6643 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6644 }
6645 {
6646 PyThreadState* __tstate = wxPyBeginAllowThreads();
6647 (arg1)->SetSize((wxSize const &)*arg2);
6648
6649 wxPyEndAllowThreads(__tstate);
6650 if (PyErr_Occurred()) SWIG_fail;
6651 }
6652 Py_INCREF(Py_None); resultobj = Py_None;
6653 return resultobj;
6654 fail:
6655 return NULL;
6656 }
6657
6658
6659 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6660 PyObject *resultobj;
6661 wxCaret *arg1 = (wxCaret *) 0 ;
6662 int arg2 = (int) true ;
6663 PyObject * obj0 = 0 ;
6664 PyObject * obj1 = 0 ;
6665 char *kwnames[] = {
6666 (char *) "self",(char *) "show", NULL
6667 };
6668
6669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6671 if (SWIG_arg_fail(1)) SWIG_fail;
6672 if (obj1) {
6673 {
6674 arg2 = (int)(SWIG_As_int(obj1));
6675 if (SWIG_arg_fail(2)) SWIG_fail;
6676 }
6677 }
6678 {
6679 PyThreadState* __tstate = wxPyBeginAllowThreads();
6680 (arg1)->Show(arg2);
6681
6682 wxPyEndAllowThreads(__tstate);
6683 if (PyErr_Occurred()) SWIG_fail;
6684 }
6685 Py_INCREF(Py_None); resultobj = Py_None;
6686 return resultobj;
6687 fail:
6688 return NULL;
6689 }
6690
6691
6692 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6693 PyObject *resultobj;
6694 wxCaret *arg1 = (wxCaret *) 0 ;
6695 PyObject * obj0 = 0 ;
6696 char *kwnames[] = {
6697 (char *) "self", NULL
6698 };
6699
6700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6702 if (SWIG_arg_fail(1)) SWIG_fail;
6703 {
6704 PyThreadState* __tstate = wxPyBeginAllowThreads();
6705 (arg1)->Hide();
6706
6707 wxPyEndAllowThreads(__tstate);
6708 if (PyErr_Occurred()) SWIG_fail;
6709 }
6710 Py_INCREF(Py_None); resultobj = Py_None;
6711 return resultobj;
6712 fail:
6713 return NULL;
6714 }
6715
6716
6717 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6718 PyObject *resultobj;
6719 int result;
6720 char *kwnames[] = {
6721 NULL
6722 };
6723
6724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6725 {
6726 PyThreadState* __tstate = wxPyBeginAllowThreads();
6727 result = (int)wxCaret::GetBlinkTime();
6728
6729 wxPyEndAllowThreads(__tstate);
6730 if (PyErr_Occurred()) SWIG_fail;
6731 }
6732 {
6733 resultobj = SWIG_From_int((int)(result));
6734 }
6735 return resultobj;
6736 fail:
6737 return NULL;
6738 }
6739
6740
6741 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6742 PyObject *resultobj;
6743 int arg1 ;
6744 PyObject * obj0 = 0 ;
6745 char *kwnames[] = {
6746 (char *) "milliseconds", NULL
6747 };
6748
6749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6750 {
6751 arg1 = (int)(SWIG_As_int(obj0));
6752 if (SWIG_arg_fail(1)) SWIG_fail;
6753 }
6754 {
6755 PyThreadState* __tstate = wxPyBeginAllowThreads();
6756 wxCaret::SetBlinkTime(arg1);
6757
6758 wxPyEndAllowThreads(__tstate);
6759 if (PyErr_Occurred()) SWIG_fail;
6760 }
6761 Py_INCREF(Py_None); resultobj = Py_None;
6762 return resultobj;
6763 fail:
6764 return NULL;
6765 }
6766
6767
6768 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6769 PyObject *obj;
6770 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6771 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6772 Py_INCREF(obj);
6773 return Py_BuildValue((char *)"");
6774 }
6775 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6776 PyObject *resultobj;
6777 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6778 wxBusyCursor *result;
6779 PyObject * obj0 = 0 ;
6780 char *kwnames[] = {
6781 (char *) "cursor", NULL
6782 };
6783
6784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6785 if (obj0) {
6786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6787 if (SWIG_arg_fail(1)) SWIG_fail;
6788 }
6789 {
6790 if (!wxPyCheckForApp()) SWIG_fail;
6791 PyThreadState* __tstate = wxPyBeginAllowThreads();
6792 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6793
6794 wxPyEndAllowThreads(__tstate);
6795 if (PyErr_Occurred()) SWIG_fail;
6796 }
6797 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6798 return resultobj;
6799 fail:
6800 return NULL;
6801 }
6802
6803
6804 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6805 PyObject *resultobj;
6806 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6807 PyObject * obj0 = 0 ;
6808 char *kwnames[] = {
6809 (char *) "self", NULL
6810 };
6811
6812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6814 if (SWIG_arg_fail(1)) SWIG_fail;
6815 {
6816 PyThreadState* __tstate = wxPyBeginAllowThreads();
6817 delete arg1;
6818
6819 wxPyEndAllowThreads(__tstate);
6820 if (PyErr_Occurred()) SWIG_fail;
6821 }
6822 Py_INCREF(Py_None); resultobj = Py_None;
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6830 PyObject *obj;
6831 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6832 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6833 Py_INCREF(obj);
6834 return Py_BuildValue((char *)"");
6835 }
6836 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6837 PyObject *resultobj;
6838 wxWindow *arg1 = (wxWindow *) NULL ;
6839 wxWindowDisabler *result;
6840 PyObject * obj0 = 0 ;
6841 char *kwnames[] = {
6842 (char *) "winToSkip", NULL
6843 };
6844
6845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6846 if (obj0) {
6847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6848 if (SWIG_arg_fail(1)) SWIG_fail;
6849 }
6850 {
6851 if (!wxPyCheckForApp()) SWIG_fail;
6852 PyThreadState* __tstate = wxPyBeginAllowThreads();
6853 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6854
6855 wxPyEndAllowThreads(__tstate);
6856 if (PyErr_Occurred()) SWIG_fail;
6857 }
6858 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6859 return resultobj;
6860 fail:
6861 return NULL;
6862 }
6863
6864
6865 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6866 PyObject *resultobj;
6867 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6868 PyObject * obj0 = 0 ;
6869 char *kwnames[] = {
6870 (char *) "self", NULL
6871 };
6872
6873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6875 if (SWIG_arg_fail(1)) SWIG_fail;
6876 {
6877 PyThreadState* __tstate = wxPyBeginAllowThreads();
6878 delete arg1;
6879
6880 wxPyEndAllowThreads(__tstate);
6881 if (PyErr_Occurred()) SWIG_fail;
6882 }
6883 Py_INCREF(Py_None); resultobj = Py_None;
6884 return resultobj;
6885 fail:
6886 return NULL;
6887 }
6888
6889
6890 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6891 PyObject *obj;
6892 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6893 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6894 Py_INCREF(obj);
6895 return Py_BuildValue((char *)"");
6896 }
6897 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6898 PyObject *resultobj;
6899 wxString *arg1 = 0 ;
6900 wxBusyInfo *result;
6901 bool temp1 = false ;
6902 PyObject * obj0 = 0 ;
6903 char *kwnames[] = {
6904 (char *) "message", NULL
6905 };
6906
6907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6908 {
6909 arg1 = wxString_in_helper(obj0);
6910 if (arg1 == NULL) SWIG_fail;
6911 temp1 = true;
6912 }
6913 {
6914 if (!wxPyCheckForApp()) SWIG_fail;
6915 PyThreadState* __tstate = wxPyBeginAllowThreads();
6916 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
6917
6918 wxPyEndAllowThreads(__tstate);
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
6922 {
6923 if (temp1)
6924 delete arg1;
6925 }
6926 return resultobj;
6927 fail:
6928 {
6929 if (temp1)
6930 delete arg1;
6931 }
6932 return NULL;
6933 }
6934
6935
6936 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6937 PyObject *resultobj;
6938 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
6939 PyObject * obj0 = 0 ;
6940 char *kwnames[] = {
6941 (char *) "self", NULL
6942 };
6943
6944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
6945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
6946 if (SWIG_arg_fail(1)) SWIG_fail;
6947 {
6948 PyThreadState* __tstate = wxPyBeginAllowThreads();
6949 delete arg1;
6950
6951 wxPyEndAllowThreads(__tstate);
6952 if (PyErr_Occurred()) SWIG_fail;
6953 }
6954 Py_INCREF(Py_None); resultobj = Py_None;
6955 return resultobj;
6956 fail:
6957 return NULL;
6958 }
6959
6960
6961 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
6962 PyObject *obj;
6963 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6964 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
6965 Py_INCREF(obj);
6966 return Py_BuildValue((char *)"");
6967 }
6968 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
6969 PyObject *resultobj;
6970 wxStopWatch *result;
6971 char *kwnames[] = {
6972 NULL
6973 };
6974
6975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
6976 {
6977 PyThreadState* __tstate = wxPyBeginAllowThreads();
6978 result = (wxStopWatch *)new wxStopWatch();
6979
6980 wxPyEndAllowThreads(__tstate);
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
6984 return resultobj;
6985 fail:
6986 return NULL;
6987 }
6988
6989
6990 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
6991 PyObject *resultobj;
6992 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
6993 long arg2 = (long) 0 ;
6994 PyObject * obj0 = 0 ;
6995 PyObject * obj1 = 0 ;
6996 char *kwnames[] = {
6997 (char *) "self",(char *) "t0", NULL
6998 };
6999
7000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7002 if (SWIG_arg_fail(1)) SWIG_fail;
7003 if (obj1) {
7004 {
7005 arg2 = (long)(SWIG_As_long(obj1));
7006 if (SWIG_arg_fail(2)) SWIG_fail;
7007 }
7008 }
7009 {
7010 PyThreadState* __tstate = wxPyBeginAllowThreads();
7011 (arg1)->Start(arg2);
7012
7013 wxPyEndAllowThreads(__tstate);
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 Py_INCREF(Py_None); resultobj = Py_None;
7017 return resultobj;
7018 fail:
7019 return NULL;
7020 }
7021
7022
7023 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7024 PyObject *resultobj;
7025 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7026 PyObject * obj0 = 0 ;
7027 char *kwnames[] = {
7028 (char *) "self", NULL
7029 };
7030
7031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7033 if (SWIG_arg_fail(1)) SWIG_fail;
7034 {
7035 PyThreadState* __tstate = wxPyBeginAllowThreads();
7036 (arg1)->Pause();
7037
7038 wxPyEndAllowThreads(__tstate);
7039 if (PyErr_Occurred()) SWIG_fail;
7040 }
7041 Py_INCREF(Py_None); resultobj = Py_None;
7042 return resultobj;
7043 fail:
7044 return NULL;
7045 }
7046
7047
7048 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7049 PyObject *resultobj;
7050 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7051 PyObject * obj0 = 0 ;
7052 char *kwnames[] = {
7053 (char *) "self", NULL
7054 };
7055
7056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7058 if (SWIG_arg_fail(1)) SWIG_fail;
7059 {
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 (arg1)->Resume();
7062
7063 wxPyEndAllowThreads(__tstate);
7064 if (PyErr_Occurred()) SWIG_fail;
7065 }
7066 Py_INCREF(Py_None); resultobj = Py_None;
7067 return resultobj;
7068 fail:
7069 return NULL;
7070 }
7071
7072
7073 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7074 PyObject *resultobj;
7075 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7076 long result;
7077 PyObject * obj0 = 0 ;
7078 char *kwnames[] = {
7079 (char *) "self", NULL
7080 };
7081
7082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7084 if (SWIG_arg_fail(1)) SWIG_fail;
7085 {
7086 PyThreadState* __tstate = wxPyBeginAllowThreads();
7087 result = (long)((wxStopWatch const *)arg1)->Time();
7088
7089 wxPyEndAllowThreads(__tstate);
7090 if (PyErr_Occurred()) SWIG_fail;
7091 }
7092 {
7093 resultobj = SWIG_From_long((long)(result));
7094 }
7095 return resultobj;
7096 fail:
7097 return NULL;
7098 }
7099
7100
7101 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7102 PyObject *obj;
7103 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7104 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7105 Py_INCREF(obj);
7106 return Py_BuildValue((char *)"");
7107 }
7108 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7109 PyObject *resultobj;
7110 int arg1 = (int) 9 ;
7111 int arg2 = (int) wxID_FILE1 ;
7112 wxFileHistory *result;
7113 PyObject * obj0 = 0 ;
7114 PyObject * obj1 = 0 ;
7115 char *kwnames[] = {
7116 (char *) "maxFiles",(char *) "idBase", NULL
7117 };
7118
7119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7120 if (obj0) {
7121 {
7122 arg1 = (int)(SWIG_As_int(obj0));
7123 if (SWIG_arg_fail(1)) SWIG_fail;
7124 }
7125 }
7126 if (obj1) {
7127 {
7128 arg2 = (int)(SWIG_As_int(obj1));
7129 if (SWIG_arg_fail(2)) SWIG_fail;
7130 }
7131 }
7132 {
7133 PyThreadState* __tstate = wxPyBeginAllowThreads();
7134 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7135
7136 wxPyEndAllowThreads(__tstate);
7137 if (PyErr_Occurred()) SWIG_fail;
7138 }
7139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7140 return resultobj;
7141 fail:
7142 return NULL;
7143 }
7144
7145
7146 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7147 PyObject *resultobj;
7148 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7149 PyObject * obj0 = 0 ;
7150 char *kwnames[] = {
7151 (char *) "self", NULL
7152 };
7153
7154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7156 if (SWIG_arg_fail(1)) SWIG_fail;
7157 {
7158 PyThreadState* __tstate = wxPyBeginAllowThreads();
7159 delete arg1;
7160
7161 wxPyEndAllowThreads(__tstate);
7162 if (PyErr_Occurred()) SWIG_fail;
7163 }
7164 Py_INCREF(Py_None); resultobj = Py_None;
7165 return resultobj;
7166 fail:
7167 return NULL;
7168 }
7169
7170
7171 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7172 PyObject *resultobj;
7173 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7174 wxString *arg2 = 0 ;
7175 bool temp2 = false ;
7176 PyObject * obj0 = 0 ;
7177 PyObject * obj1 = 0 ;
7178 char *kwnames[] = {
7179 (char *) "self",(char *) "file", NULL
7180 };
7181
7182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7184 if (SWIG_arg_fail(1)) SWIG_fail;
7185 {
7186 arg2 = wxString_in_helper(obj1);
7187 if (arg2 == NULL) SWIG_fail;
7188 temp2 = true;
7189 }
7190 {
7191 PyThreadState* __tstate = wxPyBeginAllowThreads();
7192 (arg1)->AddFileToHistory((wxString const &)*arg2);
7193
7194 wxPyEndAllowThreads(__tstate);
7195 if (PyErr_Occurred()) SWIG_fail;
7196 }
7197 Py_INCREF(Py_None); resultobj = Py_None;
7198 {
7199 if (temp2)
7200 delete arg2;
7201 }
7202 return resultobj;
7203 fail:
7204 {
7205 if (temp2)
7206 delete arg2;
7207 }
7208 return NULL;
7209 }
7210
7211
7212 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7213 PyObject *resultobj;
7214 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7215 int arg2 ;
7216 PyObject * obj0 = 0 ;
7217 PyObject * obj1 = 0 ;
7218 char *kwnames[] = {
7219 (char *) "self",(char *) "i", NULL
7220 };
7221
7222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7224 if (SWIG_arg_fail(1)) SWIG_fail;
7225 {
7226 arg2 = (int)(SWIG_As_int(obj1));
7227 if (SWIG_arg_fail(2)) SWIG_fail;
7228 }
7229 {
7230 PyThreadState* __tstate = wxPyBeginAllowThreads();
7231 (arg1)->RemoveFileFromHistory(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_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7244 PyObject *resultobj;
7245 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7246 int result;
7247 PyObject * obj0 = 0 ;
7248 char *kwnames[] = {
7249 (char *) "self", NULL
7250 };
7251
7252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7254 if (SWIG_arg_fail(1)) SWIG_fail;
7255 {
7256 PyThreadState* __tstate = wxPyBeginAllowThreads();
7257 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7258
7259 wxPyEndAllowThreads(__tstate);
7260 if (PyErr_Occurred()) SWIG_fail;
7261 }
7262 {
7263 resultobj = SWIG_From_int((int)(result));
7264 }
7265 return resultobj;
7266 fail:
7267 return NULL;
7268 }
7269
7270
7271 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7272 PyObject *resultobj;
7273 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7274 wxMenu *arg2 = (wxMenu *) 0 ;
7275 PyObject * obj0 = 0 ;
7276 PyObject * obj1 = 0 ;
7277 char *kwnames[] = {
7278 (char *) "self",(char *) "menu", NULL
7279 };
7280
7281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7283 if (SWIG_arg_fail(1)) SWIG_fail;
7284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7285 if (SWIG_arg_fail(2)) SWIG_fail;
7286 {
7287 PyThreadState* __tstate = wxPyBeginAllowThreads();
7288 (arg1)->UseMenu(arg2);
7289
7290 wxPyEndAllowThreads(__tstate);
7291 if (PyErr_Occurred()) SWIG_fail;
7292 }
7293 Py_INCREF(Py_None); resultobj = Py_None;
7294 return resultobj;
7295 fail:
7296 return NULL;
7297 }
7298
7299
7300 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7301 PyObject *resultobj;
7302 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7303 wxMenu *arg2 = (wxMenu *) 0 ;
7304 PyObject * obj0 = 0 ;
7305 PyObject * obj1 = 0 ;
7306 char *kwnames[] = {
7307 (char *) "self",(char *) "menu", NULL
7308 };
7309
7310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7312 if (SWIG_arg_fail(1)) SWIG_fail;
7313 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7314 if (SWIG_arg_fail(2)) SWIG_fail;
7315 {
7316 PyThreadState* __tstate = wxPyBeginAllowThreads();
7317 (arg1)->RemoveMenu(arg2);
7318
7319 wxPyEndAllowThreads(__tstate);
7320 if (PyErr_Occurred()) SWIG_fail;
7321 }
7322 Py_INCREF(Py_None); resultobj = Py_None;
7323 return resultobj;
7324 fail:
7325 return NULL;
7326 }
7327
7328
7329 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7330 PyObject *resultobj;
7331 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7332 wxConfigBase *arg2 = 0 ;
7333 PyObject * obj0 = 0 ;
7334 PyObject * obj1 = 0 ;
7335 char *kwnames[] = {
7336 (char *) "self",(char *) "config", NULL
7337 };
7338
7339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7341 if (SWIG_arg_fail(1)) SWIG_fail;
7342 {
7343 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7344 if (SWIG_arg_fail(2)) SWIG_fail;
7345 if (arg2 == NULL) {
7346 SWIG_null_ref("wxConfigBase");
7347 }
7348 if (SWIG_arg_fail(2)) SWIG_fail;
7349 }
7350 {
7351 PyThreadState* __tstate = wxPyBeginAllowThreads();
7352 (arg1)->Load(*arg2);
7353
7354 wxPyEndAllowThreads(__tstate);
7355 if (PyErr_Occurred()) SWIG_fail;
7356 }
7357 Py_INCREF(Py_None); resultobj = Py_None;
7358 return resultobj;
7359 fail:
7360 return NULL;
7361 }
7362
7363
7364 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7365 PyObject *resultobj;
7366 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7367 wxConfigBase *arg2 = 0 ;
7368 PyObject * obj0 = 0 ;
7369 PyObject * obj1 = 0 ;
7370 char *kwnames[] = {
7371 (char *) "self",(char *) "config", NULL
7372 };
7373
7374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7379 if (SWIG_arg_fail(2)) SWIG_fail;
7380 if (arg2 == NULL) {
7381 SWIG_null_ref("wxConfigBase");
7382 }
7383 if (SWIG_arg_fail(2)) SWIG_fail;
7384 }
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 (arg1)->Save(*arg2);
7388
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 Py_INCREF(Py_None); resultobj = Py_None;
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj;
7401 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7402 PyObject * obj0 = 0 ;
7403 char *kwnames[] = {
7404 (char *) "self", NULL
7405 };
7406
7407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7409 if (SWIG_arg_fail(1)) SWIG_fail;
7410 {
7411 PyThreadState* __tstate = wxPyBeginAllowThreads();
7412 (arg1)->AddFilesToMenu();
7413
7414 wxPyEndAllowThreads(__tstate);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 Py_INCREF(Py_None); resultobj = Py_None;
7418 return resultobj;
7419 fail:
7420 return NULL;
7421 }
7422
7423
7424 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7425 PyObject *resultobj;
7426 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7427 wxMenu *arg2 = (wxMenu *) 0 ;
7428 PyObject * obj0 = 0 ;
7429 PyObject * obj1 = 0 ;
7430 char *kwnames[] = {
7431 (char *) "self",(char *) "menu", NULL
7432 };
7433
7434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7436 if (SWIG_arg_fail(1)) SWIG_fail;
7437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7438 if (SWIG_arg_fail(2)) SWIG_fail;
7439 {
7440 PyThreadState* __tstate = wxPyBeginAllowThreads();
7441 (arg1)->AddFilesToMenu(arg2);
7442
7443 wxPyEndAllowThreads(__tstate);
7444 if (PyErr_Occurred()) SWIG_fail;
7445 }
7446 Py_INCREF(Py_None); resultobj = Py_None;
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
7453 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7454 PyObject *resultobj;
7455 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7456 int arg2 ;
7457 wxString result;
7458 PyObject * obj0 = 0 ;
7459 PyObject * obj1 = 0 ;
7460 char *kwnames[] = {
7461 (char *) "self",(char *) "i", NULL
7462 };
7463
7464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7466 if (SWIG_arg_fail(1)) SWIG_fail;
7467 {
7468 arg2 = (int)(SWIG_As_int(obj1));
7469 if (SWIG_arg_fail(2)) SWIG_fail;
7470 }
7471 {
7472 PyThreadState* __tstate = wxPyBeginAllowThreads();
7473 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7474
7475 wxPyEndAllowThreads(__tstate);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 {
7479 #if wxUSE_UNICODE
7480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7481 #else
7482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7483 #endif
7484 }
7485 return resultobj;
7486 fail:
7487 return NULL;
7488 }
7489
7490
7491 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7492 PyObject *resultobj;
7493 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7494 int result;
7495 PyObject * obj0 = 0 ;
7496 char *kwnames[] = {
7497 (char *) "self", NULL
7498 };
7499
7500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7502 if (SWIG_arg_fail(1)) SWIG_fail;
7503 {
7504 PyThreadState* __tstate = wxPyBeginAllowThreads();
7505 result = (int)((wxFileHistory const *)arg1)->GetCount();
7506
7507 wxPyEndAllowThreads(__tstate);
7508 if (PyErr_Occurred()) SWIG_fail;
7509 }
7510 {
7511 resultobj = SWIG_From_int((int)(result));
7512 }
7513 return resultobj;
7514 fail:
7515 return NULL;
7516 }
7517
7518
7519 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7520 PyObject *obj;
7521 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7522 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7523 Py_INCREF(obj);
7524 return Py_BuildValue((char *)"");
7525 }
7526 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7527 PyObject *resultobj;
7528 wxString *arg1 = 0 ;
7529 wxString const &arg2_defvalue = wxPyEmptyString ;
7530 wxString *arg2 = (wxString *) &arg2_defvalue ;
7531 wxSingleInstanceChecker *result;
7532 bool temp1 = false ;
7533 bool temp2 = false ;
7534 PyObject * obj0 = 0 ;
7535 PyObject * obj1 = 0 ;
7536 char *kwnames[] = {
7537 (char *) "name",(char *) "path", NULL
7538 };
7539
7540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7541 {
7542 arg1 = wxString_in_helper(obj0);
7543 if (arg1 == NULL) SWIG_fail;
7544 temp1 = true;
7545 }
7546 if (obj1) {
7547 {
7548 arg2 = wxString_in_helper(obj1);
7549 if (arg2 == NULL) SWIG_fail;
7550 temp2 = true;
7551 }
7552 }
7553 {
7554 PyThreadState* __tstate = wxPyBeginAllowThreads();
7555 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7556
7557 wxPyEndAllowThreads(__tstate);
7558 if (PyErr_Occurred()) SWIG_fail;
7559 }
7560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7561 {
7562 if (temp1)
7563 delete arg1;
7564 }
7565 {
7566 if (temp2)
7567 delete arg2;
7568 }
7569 return resultobj;
7570 fail:
7571 {
7572 if (temp1)
7573 delete arg1;
7574 }
7575 {
7576 if (temp2)
7577 delete arg2;
7578 }
7579 return NULL;
7580 }
7581
7582
7583 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj;
7585 wxSingleInstanceChecker *result;
7586 char *kwnames[] = {
7587 NULL
7588 };
7589
7590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7594
7595 wxPyEndAllowThreads(__tstate);
7596 if (PyErr_Occurred()) SWIG_fail;
7597 }
7598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7599 return resultobj;
7600 fail:
7601 return NULL;
7602 }
7603
7604
7605 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7606 PyObject *resultobj;
7607 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7608 PyObject * obj0 = 0 ;
7609 char *kwnames[] = {
7610 (char *) "self", NULL
7611 };
7612
7613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7615 if (SWIG_arg_fail(1)) SWIG_fail;
7616 {
7617 PyThreadState* __tstate = wxPyBeginAllowThreads();
7618 delete arg1;
7619
7620 wxPyEndAllowThreads(__tstate);
7621 if (PyErr_Occurred()) SWIG_fail;
7622 }
7623 Py_INCREF(Py_None); resultobj = Py_None;
7624 return resultobj;
7625 fail:
7626 return NULL;
7627 }
7628
7629
7630 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7631 PyObject *resultobj;
7632 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7633 wxString *arg2 = 0 ;
7634 wxString const &arg3_defvalue = wxPyEmptyString ;
7635 wxString *arg3 = (wxString *) &arg3_defvalue ;
7636 bool result;
7637 bool temp2 = false ;
7638 bool temp3 = false ;
7639 PyObject * obj0 = 0 ;
7640 PyObject * obj1 = 0 ;
7641 PyObject * obj2 = 0 ;
7642 char *kwnames[] = {
7643 (char *) "self",(char *) "name",(char *) "path", NULL
7644 };
7645
7646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7648 if (SWIG_arg_fail(1)) SWIG_fail;
7649 {
7650 arg2 = wxString_in_helper(obj1);
7651 if (arg2 == NULL) SWIG_fail;
7652 temp2 = true;
7653 }
7654 if (obj2) {
7655 {
7656 arg3 = wxString_in_helper(obj2);
7657 if (arg3 == NULL) SWIG_fail;
7658 temp3 = true;
7659 }
7660 }
7661 {
7662 PyThreadState* __tstate = wxPyBeginAllowThreads();
7663 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7664
7665 wxPyEndAllowThreads(__tstate);
7666 if (PyErr_Occurred()) SWIG_fail;
7667 }
7668 {
7669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7670 }
7671 {
7672 if (temp2)
7673 delete arg2;
7674 }
7675 {
7676 if (temp3)
7677 delete arg3;
7678 }
7679 return resultobj;
7680 fail:
7681 {
7682 if (temp2)
7683 delete arg2;
7684 }
7685 {
7686 if (temp3)
7687 delete arg3;
7688 }
7689 return NULL;
7690 }
7691
7692
7693 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7694 PyObject *resultobj;
7695 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7696 bool result;
7697 PyObject * obj0 = 0 ;
7698 char *kwnames[] = {
7699 (char *) "self", NULL
7700 };
7701
7702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7704 if (SWIG_arg_fail(1)) SWIG_fail;
7705 {
7706 PyThreadState* __tstate = wxPyBeginAllowThreads();
7707 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7708
7709 wxPyEndAllowThreads(__tstate);
7710 if (PyErr_Occurred()) SWIG_fail;
7711 }
7712 {
7713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7714 }
7715 return resultobj;
7716 fail:
7717 return NULL;
7718 }
7719
7720
7721 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7722 PyObject *obj;
7723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7724 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7725 Py_INCREF(obj);
7726 return Py_BuildValue((char *)"");
7727 }
7728 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7729 PyObject *resultobj;
7730 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7731 PyObject * obj0 = 0 ;
7732 char *kwnames[] = {
7733 (char *) "self", NULL
7734 };
7735
7736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7738 if (SWIG_arg_fail(1)) SWIG_fail;
7739 {
7740 PyThreadState* __tstate = wxPyBeginAllowThreads();
7741 delete arg1;
7742
7743 wxPyEndAllowThreads(__tstate);
7744 if (PyErr_Occurred()) SWIG_fail;
7745 }
7746 Py_INCREF(Py_None); resultobj = Py_None;
7747 return resultobj;
7748 fail:
7749 return NULL;
7750 }
7751
7752
7753 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7754 PyObject *resultobj;
7755 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7756 wxString result;
7757 PyObject * obj0 = 0 ;
7758 char *kwnames[] = {
7759 (char *) "self", NULL
7760 };
7761
7762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7764 if (SWIG_arg_fail(1)) SWIG_fail;
7765 {
7766 PyThreadState* __tstate = wxPyBeginAllowThreads();
7767 result = (arg1)->GetTip();
7768
7769 wxPyEndAllowThreads(__tstate);
7770 if (PyErr_Occurred()) SWIG_fail;
7771 }
7772 {
7773 #if wxUSE_UNICODE
7774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7775 #else
7776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7777 #endif
7778 }
7779 return resultobj;
7780 fail:
7781 return NULL;
7782 }
7783
7784
7785 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7786 PyObject *resultobj;
7787 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7788 size_t result;
7789 PyObject * obj0 = 0 ;
7790 char *kwnames[] = {
7791 (char *) "self", NULL
7792 };
7793
7794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7796 if (SWIG_arg_fail(1)) SWIG_fail;
7797 {
7798 PyThreadState* __tstate = wxPyBeginAllowThreads();
7799 result = (size_t)(arg1)->GetCurrentTip();
7800
7801 wxPyEndAllowThreads(__tstate);
7802 if (PyErr_Occurred()) SWIG_fail;
7803 }
7804 {
7805 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7806 }
7807 return resultobj;
7808 fail:
7809 return NULL;
7810 }
7811
7812
7813 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7814 PyObject *resultobj;
7815 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7816 wxString *arg2 = 0 ;
7817 wxString result;
7818 bool temp2 = false ;
7819 PyObject * obj0 = 0 ;
7820 PyObject * obj1 = 0 ;
7821 char *kwnames[] = {
7822 (char *) "self",(char *) "tip", NULL
7823 };
7824
7825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7827 if (SWIG_arg_fail(1)) SWIG_fail;
7828 {
7829 arg2 = wxString_in_helper(obj1);
7830 if (arg2 == NULL) SWIG_fail;
7831 temp2 = true;
7832 }
7833 {
7834 PyThreadState* __tstate = wxPyBeginAllowThreads();
7835 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7836
7837 wxPyEndAllowThreads(__tstate);
7838 if (PyErr_Occurred()) SWIG_fail;
7839 }
7840 {
7841 #if wxUSE_UNICODE
7842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7843 #else
7844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7845 #endif
7846 }
7847 {
7848 if (temp2)
7849 delete arg2;
7850 }
7851 return resultobj;
7852 fail:
7853 {
7854 if (temp2)
7855 delete arg2;
7856 }
7857 return NULL;
7858 }
7859
7860
7861 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7862 PyObject *obj;
7863 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7864 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7865 Py_INCREF(obj);
7866 return Py_BuildValue((char *)"");
7867 }
7868 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7869 PyObject *resultobj;
7870 size_t arg1 ;
7871 wxPyTipProvider *result;
7872 PyObject * obj0 = 0 ;
7873 char *kwnames[] = {
7874 (char *) "currentTip", NULL
7875 };
7876
7877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
7878 {
7879 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
7880 if (SWIG_arg_fail(1)) SWIG_fail;
7881 }
7882 {
7883 PyThreadState* __tstate = wxPyBeginAllowThreads();
7884 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
7885
7886 wxPyEndAllowThreads(__tstate);
7887 if (PyErr_Occurred()) SWIG_fail;
7888 }
7889 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
7890 return resultobj;
7891 fail:
7892 return NULL;
7893 }
7894
7895
7896 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7897 PyObject *resultobj;
7898 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
7899 PyObject *arg2 = (PyObject *) 0 ;
7900 PyObject *arg3 = (PyObject *) 0 ;
7901 PyObject * obj0 = 0 ;
7902 PyObject * obj1 = 0 ;
7903 PyObject * obj2 = 0 ;
7904 char *kwnames[] = {
7905 (char *) "self",(char *) "self",(char *) "_class", NULL
7906 };
7907
7908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
7909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
7910 if (SWIG_arg_fail(1)) SWIG_fail;
7911 arg2 = obj1;
7912 arg3 = obj2;
7913 {
7914 PyThreadState* __tstate = wxPyBeginAllowThreads();
7915 (arg1)->_setCallbackInfo(arg2,arg3);
7916
7917 wxPyEndAllowThreads(__tstate);
7918 if (PyErr_Occurred()) SWIG_fail;
7919 }
7920 Py_INCREF(Py_None); resultobj = Py_None;
7921 return resultobj;
7922 fail:
7923 return NULL;
7924 }
7925
7926
7927 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
7928 PyObject *obj;
7929 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7930 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
7931 Py_INCREF(obj);
7932 return Py_BuildValue((char *)"");
7933 }
7934 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
7935 PyObject *resultobj;
7936 wxWindow *arg1 = (wxWindow *) 0 ;
7937 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
7938 bool arg3 = (bool) true ;
7939 bool result;
7940 PyObject * obj0 = 0 ;
7941 PyObject * obj1 = 0 ;
7942 PyObject * obj2 = 0 ;
7943 char *kwnames[] = {
7944 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
7945 };
7946
7947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
7948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7949 if (SWIG_arg_fail(1)) SWIG_fail;
7950 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7951 if (SWIG_arg_fail(2)) SWIG_fail;
7952 if (obj2) {
7953 {
7954 arg3 = (bool)(SWIG_As_bool(obj2));
7955 if (SWIG_arg_fail(3)) SWIG_fail;
7956 }
7957 }
7958 {
7959 if (!wxPyCheckForApp()) SWIG_fail;
7960 PyThreadState* __tstate = wxPyBeginAllowThreads();
7961 result = (bool)wxShowTip(arg1,arg2,arg3);
7962
7963 wxPyEndAllowThreads(__tstate);
7964 if (PyErr_Occurred()) SWIG_fail;
7965 }
7966 {
7967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7968 }
7969 return resultobj;
7970 fail:
7971 return NULL;
7972 }
7973
7974
7975 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7976 PyObject *resultobj;
7977 wxString *arg1 = 0 ;
7978 size_t arg2 ;
7979 wxTipProvider *result;
7980 bool temp1 = false ;
7981 PyObject * obj0 = 0 ;
7982 PyObject * obj1 = 0 ;
7983 char *kwnames[] = {
7984 (char *) "filename",(char *) "currentTip", NULL
7985 };
7986
7987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
7988 {
7989 arg1 = wxString_in_helper(obj0);
7990 if (arg1 == NULL) SWIG_fail;
7991 temp1 = true;
7992 }
7993 {
7994 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7995 if (SWIG_arg_fail(2)) SWIG_fail;
7996 }
7997 {
7998 if (!wxPyCheckForApp()) SWIG_fail;
7999 PyThreadState* __tstate = wxPyBeginAllowThreads();
8000 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8001
8002 wxPyEndAllowThreads(__tstate);
8003 if (PyErr_Occurred()) SWIG_fail;
8004 }
8005 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8006 {
8007 if (temp1)
8008 delete arg1;
8009 }
8010 return resultobj;
8011 fail:
8012 {
8013 if (temp1)
8014 delete arg1;
8015 }
8016 return NULL;
8017 }
8018
8019
8020 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8021 PyObject *resultobj;
8022 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8023 int arg2 = (int) -1 ;
8024 wxPyTimer *result;
8025 PyObject * obj0 = 0 ;
8026 PyObject * obj1 = 0 ;
8027 char *kwnames[] = {
8028 (char *) "owner",(char *) "id", NULL
8029 };
8030
8031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8032 if (obj0) {
8033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8034 if (SWIG_arg_fail(1)) SWIG_fail;
8035 }
8036 if (obj1) {
8037 {
8038 arg2 = (int)(SWIG_As_int(obj1));
8039 if (SWIG_arg_fail(2)) SWIG_fail;
8040 }
8041 }
8042 {
8043 if (!wxPyCheckForApp()) SWIG_fail;
8044 PyThreadState* __tstate = wxPyBeginAllowThreads();
8045 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8046
8047 wxPyEndAllowThreads(__tstate);
8048 if (PyErr_Occurred()) SWIG_fail;
8049 }
8050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8051 return resultobj;
8052 fail:
8053 return NULL;
8054 }
8055
8056
8057 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8058 PyObject *resultobj;
8059 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8060 PyObject * obj0 = 0 ;
8061 char *kwnames[] = {
8062 (char *) "self", NULL
8063 };
8064
8065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8067 if (SWIG_arg_fail(1)) SWIG_fail;
8068 {
8069 PyThreadState* __tstate = wxPyBeginAllowThreads();
8070 delete arg1;
8071
8072 wxPyEndAllowThreads(__tstate);
8073 if (PyErr_Occurred()) SWIG_fail;
8074 }
8075 Py_INCREF(Py_None); resultobj = Py_None;
8076 return resultobj;
8077 fail:
8078 return NULL;
8079 }
8080
8081
8082 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8083 PyObject *resultobj;
8084 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8085 PyObject *arg2 = (PyObject *) 0 ;
8086 PyObject *arg3 = (PyObject *) 0 ;
8087 int arg4 = (int) 1 ;
8088 PyObject * obj0 = 0 ;
8089 PyObject * obj1 = 0 ;
8090 PyObject * obj2 = 0 ;
8091 PyObject * obj3 = 0 ;
8092 char *kwnames[] = {
8093 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8094 };
8095
8096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8098 if (SWIG_arg_fail(1)) SWIG_fail;
8099 arg2 = obj1;
8100 arg3 = obj2;
8101 if (obj3) {
8102 {
8103 arg4 = (int)(SWIG_As_int(obj3));
8104 if (SWIG_arg_fail(4)) SWIG_fail;
8105 }
8106 }
8107 {
8108 PyThreadState* __tstate = wxPyBeginAllowThreads();
8109 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8110
8111 wxPyEndAllowThreads(__tstate);
8112 if (PyErr_Occurred()) SWIG_fail;
8113 }
8114 Py_INCREF(Py_None); resultobj = Py_None;
8115 return resultobj;
8116 fail:
8117 return NULL;
8118 }
8119
8120
8121 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8122 PyObject *resultobj;
8123 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8124 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8125 int arg3 = (int) -1 ;
8126 PyObject * obj0 = 0 ;
8127 PyObject * obj1 = 0 ;
8128 PyObject * obj2 = 0 ;
8129 char *kwnames[] = {
8130 (char *) "self",(char *) "owner",(char *) "id", NULL
8131 };
8132
8133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8135 if (SWIG_arg_fail(1)) SWIG_fail;
8136 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8137 if (SWIG_arg_fail(2)) SWIG_fail;
8138 if (obj2) {
8139 {
8140 arg3 = (int)(SWIG_As_int(obj2));
8141 if (SWIG_arg_fail(3)) SWIG_fail;
8142 }
8143 }
8144 {
8145 PyThreadState* __tstate = wxPyBeginAllowThreads();
8146 (arg1)->SetOwner(arg2,arg3);
8147
8148 wxPyEndAllowThreads(__tstate);
8149 if (PyErr_Occurred()) SWIG_fail;
8150 }
8151 Py_INCREF(Py_None); resultobj = Py_None;
8152 return resultobj;
8153 fail:
8154 return NULL;
8155 }
8156
8157
8158 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8159 PyObject *resultobj;
8160 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8161 wxEvtHandler *result;
8162 PyObject * obj0 = 0 ;
8163 char *kwnames[] = {
8164 (char *) "self", NULL
8165 };
8166
8167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8169 if (SWIG_arg_fail(1)) SWIG_fail;
8170 {
8171 PyThreadState* __tstate = wxPyBeginAllowThreads();
8172 result = (wxEvtHandler *)(arg1)->GetOwner();
8173
8174 wxPyEndAllowThreads(__tstate);
8175 if (PyErr_Occurred()) SWIG_fail;
8176 }
8177 {
8178 resultobj = wxPyMake_wxObject(result, 0);
8179 }
8180 return resultobj;
8181 fail:
8182 return NULL;
8183 }
8184
8185
8186 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8187 PyObject *resultobj;
8188 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8189 int arg2 = (int) -1 ;
8190 bool arg3 = (bool) false ;
8191 bool result;
8192 PyObject * obj0 = 0 ;
8193 PyObject * obj1 = 0 ;
8194 PyObject * obj2 = 0 ;
8195 char *kwnames[] = {
8196 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8197 };
8198
8199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8201 if (SWIG_arg_fail(1)) SWIG_fail;
8202 if (obj1) {
8203 {
8204 arg2 = (int)(SWIG_As_int(obj1));
8205 if (SWIG_arg_fail(2)) SWIG_fail;
8206 }
8207 }
8208 if (obj2) {
8209 {
8210 arg3 = (bool)(SWIG_As_bool(obj2));
8211 if (SWIG_arg_fail(3)) SWIG_fail;
8212 }
8213 }
8214 {
8215 PyThreadState* __tstate = wxPyBeginAllowThreads();
8216 result = (bool)(arg1)->Start(arg2,arg3);
8217
8218 wxPyEndAllowThreads(__tstate);
8219 if (PyErr_Occurred()) SWIG_fail;
8220 }
8221 {
8222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8223 }
8224 return resultobj;
8225 fail:
8226 return NULL;
8227 }
8228
8229
8230 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8231 PyObject *resultobj;
8232 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8233 PyObject * obj0 = 0 ;
8234 char *kwnames[] = {
8235 (char *) "self", NULL
8236 };
8237
8238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8240 if (SWIG_arg_fail(1)) SWIG_fail;
8241 {
8242 PyThreadState* __tstate = wxPyBeginAllowThreads();
8243 (arg1)->Stop();
8244
8245 wxPyEndAllowThreads(__tstate);
8246 if (PyErr_Occurred()) SWIG_fail;
8247 }
8248 Py_INCREF(Py_None); resultobj = Py_None;
8249 return resultobj;
8250 fail:
8251 return NULL;
8252 }
8253
8254
8255 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8256 PyObject *resultobj;
8257 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8258 bool result;
8259 PyObject * obj0 = 0 ;
8260 char *kwnames[] = {
8261 (char *) "self", NULL
8262 };
8263
8264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8266 if (SWIG_arg_fail(1)) SWIG_fail;
8267 {
8268 PyThreadState* __tstate = wxPyBeginAllowThreads();
8269 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8270
8271 wxPyEndAllowThreads(__tstate);
8272 if (PyErr_Occurred()) SWIG_fail;
8273 }
8274 {
8275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8276 }
8277 return resultobj;
8278 fail:
8279 return NULL;
8280 }
8281
8282
8283 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8284 PyObject *resultobj;
8285 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8286 int result;
8287 PyObject * obj0 = 0 ;
8288 char *kwnames[] = {
8289 (char *) "self", NULL
8290 };
8291
8292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8294 if (SWIG_arg_fail(1)) SWIG_fail;
8295 {
8296 PyThreadState* __tstate = wxPyBeginAllowThreads();
8297 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8298
8299 wxPyEndAllowThreads(__tstate);
8300 if (PyErr_Occurred()) SWIG_fail;
8301 }
8302 {
8303 resultobj = SWIG_From_int((int)(result));
8304 }
8305 return resultobj;
8306 fail:
8307 return NULL;
8308 }
8309
8310
8311 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8312 PyObject *resultobj;
8313 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8314 bool result;
8315 PyObject * obj0 = 0 ;
8316 char *kwnames[] = {
8317 (char *) "self", NULL
8318 };
8319
8320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8322 if (SWIG_arg_fail(1)) SWIG_fail;
8323 {
8324 PyThreadState* __tstate = wxPyBeginAllowThreads();
8325 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8326
8327 wxPyEndAllowThreads(__tstate);
8328 if (PyErr_Occurred()) SWIG_fail;
8329 }
8330 {
8331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8332 }
8333 return resultobj;
8334 fail:
8335 return NULL;
8336 }
8337
8338
8339 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj;
8341 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8342 int result;
8343 PyObject * obj0 = 0 ;
8344 char *kwnames[] = {
8345 (char *) "self", NULL
8346 };
8347
8348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8350 if (SWIG_arg_fail(1)) SWIG_fail;
8351 {
8352 PyThreadState* __tstate = wxPyBeginAllowThreads();
8353 result = (int)((wxPyTimer const *)arg1)->GetId();
8354
8355 wxPyEndAllowThreads(__tstate);
8356 if (PyErr_Occurred()) SWIG_fail;
8357 }
8358 {
8359 resultobj = SWIG_From_int((int)(result));
8360 }
8361 return resultobj;
8362 fail:
8363 return NULL;
8364 }
8365
8366
8367 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8368 PyObject *obj;
8369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8370 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8371 Py_INCREF(obj);
8372 return Py_BuildValue((char *)"");
8373 }
8374 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8375 PyObject *resultobj;
8376 int arg1 = (int) 0 ;
8377 int arg2 = (int) 0 ;
8378 wxTimerEvent *result;
8379 PyObject * obj0 = 0 ;
8380 PyObject * obj1 = 0 ;
8381 char *kwnames[] = {
8382 (char *) "timerid",(char *) "interval", NULL
8383 };
8384
8385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8386 if (obj0) {
8387 {
8388 arg1 = (int)(SWIG_As_int(obj0));
8389 if (SWIG_arg_fail(1)) SWIG_fail;
8390 }
8391 }
8392 if (obj1) {
8393 {
8394 arg2 = (int)(SWIG_As_int(obj1));
8395 if (SWIG_arg_fail(2)) SWIG_fail;
8396 }
8397 }
8398 {
8399 PyThreadState* __tstate = wxPyBeginAllowThreads();
8400 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8401
8402 wxPyEndAllowThreads(__tstate);
8403 if (PyErr_Occurred()) SWIG_fail;
8404 }
8405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8406 return resultobj;
8407 fail:
8408 return NULL;
8409 }
8410
8411
8412 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8413 PyObject *resultobj;
8414 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8415 int result;
8416 PyObject * obj0 = 0 ;
8417 char *kwnames[] = {
8418 (char *) "self", NULL
8419 };
8420
8421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8423 if (SWIG_arg_fail(1)) SWIG_fail;
8424 {
8425 PyThreadState* __tstate = wxPyBeginAllowThreads();
8426 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8427
8428 wxPyEndAllowThreads(__tstate);
8429 if (PyErr_Occurred()) SWIG_fail;
8430 }
8431 {
8432 resultobj = SWIG_From_int((int)(result));
8433 }
8434 return resultobj;
8435 fail:
8436 return NULL;
8437 }
8438
8439
8440 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8441 PyObject *obj;
8442 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8443 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8444 Py_INCREF(obj);
8445 return Py_BuildValue((char *)"");
8446 }
8447 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8448 PyObject *resultobj;
8449 wxTimer *arg1 = 0 ;
8450 wxTimerRunner *result;
8451 PyObject * obj0 = 0 ;
8452
8453 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8454 {
8455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8456 if (SWIG_arg_fail(1)) SWIG_fail;
8457 if (arg1 == NULL) {
8458 SWIG_null_ref("wxTimer");
8459 }
8460 if (SWIG_arg_fail(1)) SWIG_fail;
8461 }
8462 {
8463 if (!wxPyCheckForApp()) SWIG_fail;
8464 PyThreadState* __tstate = wxPyBeginAllowThreads();
8465 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8466
8467 wxPyEndAllowThreads(__tstate);
8468 if (PyErr_Occurred()) SWIG_fail;
8469 }
8470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8471 return resultobj;
8472 fail:
8473 return NULL;
8474 }
8475
8476
8477 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8478 PyObject *resultobj;
8479 wxTimer *arg1 = 0 ;
8480 int arg2 ;
8481 bool arg3 = (bool) false ;
8482 wxTimerRunner *result;
8483 PyObject * obj0 = 0 ;
8484 PyObject * obj1 = 0 ;
8485 PyObject * obj2 = 0 ;
8486
8487 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8488 {
8489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8490 if (SWIG_arg_fail(1)) SWIG_fail;
8491 if (arg1 == NULL) {
8492 SWIG_null_ref("wxTimer");
8493 }
8494 if (SWIG_arg_fail(1)) SWIG_fail;
8495 }
8496 {
8497 arg2 = (int)(SWIG_As_int(obj1));
8498 if (SWIG_arg_fail(2)) SWIG_fail;
8499 }
8500 if (obj2) {
8501 {
8502 arg3 = (bool)(SWIG_As_bool(obj2));
8503 if (SWIG_arg_fail(3)) SWIG_fail;
8504 }
8505 }
8506 {
8507 if (!wxPyCheckForApp()) SWIG_fail;
8508 PyThreadState* __tstate = wxPyBeginAllowThreads();
8509 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8510
8511 wxPyEndAllowThreads(__tstate);
8512 if (PyErr_Occurred()) SWIG_fail;
8513 }
8514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8515 return resultobj;
8516 fail:
8517 return NULL;
8518 }
8519
8520
8521 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8522 int argc;
8523 PyObject *argv[4];
8524 int ii;
8525
8526 argc = PyObject_Length(args);
8527 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8528 argv[ii] = PyTuple_GetItem(args,ii);
8529 }
8530 if (argc == 1) {
8531 int _v;
8532 {
8533 void *ptr = 0;
8534 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8535 _v = 0;
8536 PyErr_Clear();
8537 } else {
8538 _v = (ptr != 0);
8539 }
8540 }
8541 if (_v) {
8542 return _wrap_new_TimerRunner__SWIG_0(self,args);
8543 }
8544 }
8545 if ((argc >= 2) && (argc <= 3)) {
8546 int _v;
8547 {
8548 void *ptr = 0;
8549 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8550 _v = 0;
8551 PyErr_Clear();
8552 } else {
8553 _v = (ptr != 0);
8554 }
8555 }
8556 if (_v) {
8557 _v = SWIG_Check_int(argv[1]);
8558 if (_v) {
8559 if (argc <= 2) {
8560 return _wrap_new_TimerRunner__SWIG_1(self,args);
8561 }
8562 _v = SWIG_Check_bool(argv[2]);
8563 if (_v) {
8564 return _wrap_new_TimerRunner__SWIG_1(self,args);
8565 }
8566 }
8567 }
8568 }
8569
8570 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8571 return NULL;
8572 }
8573
8574
8575 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8576 PyObject *resultobj;
8577 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8578 PyObject * obj0 = 0 ;
8579 char *kwnames[] = {
8580 (char *) "self", NULL
8581 };
8582
8583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8585 if (SWIG_arg_fail(1)) SWIG_fail;
8586 {
8587 PyThreadState* __tstate = wxPyBeginAllowThreads();
8588 delete arg1;
8589
8590 wxPyEndAllowThreads(__tstate);
8591 if (PyErr_Occurred()) SWIG_fail;
8592 }
8593 Py_INCREF(Py_None); resultobj = Py_None;
8594 return resultobj;
8595 fail:
8596 return NULL;
8597 }
8598
8599
8600 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8601 PyObject *resultobj;
8602 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8603 int arg2 ;
8604 bool arg3 = (bool) false ;
8605 PyObject * obj0 = 0 ;
8606 PyObject * obj1 = 0 ;
8607 PyObject * obj2 = 0 ;
8608 char *kwnames[] = {
8609 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8610 };
8611
8612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8614 if (SWIG_arg_fail(1)) SWIG_fail;
8615 {
8616 arg2 = (int)(SWIG_As_int(obj1));
8617 if (SWIG_arg_fail(2)) SWIG_fail;
8618 }
8619 if (obj2) {
8620 {
8621 arg3 = (bool)(SWIG_As_bool(obj2));
8622 if (SWIG_arg_fail(3)) SWIG_fail;
8623 }
8624 }
8625 {
8626 PyThreadState* __tstate = wxPyBeginAllowThreads();
8627 (arg1)->Start(arg2,arg3);
8628
8629 wxPyEndAllowThreads(__tstate);
8630 if (PyErr_Occurred()) SWIG_fail;
8631 }
8632 Py_INCREF(Py_None); resultobj = Py_None;
8633 return resultobj;
8634 fail:
8635 return NULL;
8636 }
8637
8638
8639 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8640 PyObject *obj;
8641 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8642 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8643 Py_INCREF(obj);
8644 return Py_BuildValue((char *)"");
8645 }
8646 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8647 PyObject *resultobj;
8648 wxLog *result;
8649 char *kwnames[] = {
8650 NULL
8651 };
8652
8653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8654 {
8655 PyThreadState* __tstate = wxPyBeginAllowThreads();
8656 result = (wxLog *)new wxLog();
8657
8658 wxPyEndAllowThreads(__tstate);
8659 if (PyErr_Occurred()) SWIG_fail;
8660 }
8661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8662 return resultobj;
8663 fail:
8664 return NULL;
8665 }
8666
8667
8668 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8669 PyObject *resultobj;
8670 bool result;
8671 char *kwnames[] = {
8672 NULL
8673 };
8674
8675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8676 {
8677 PyThreadState* __tstate = wxPyBeginAllowThreads();
8678 result = (bool)wxLog::IsEnabled();
8679
8680 wxPyEndAllowThreads(__tstate);
8681 if (PyErr_Occurred()) SWIG_fail;
8682 }
8683 {
8684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8685 }
8686 return resultobj;
8687 fail:
8688 return NULL;
8689 }
8690
8691
8692 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8693 PyObject *resultobj;
8694 bool arg1 = (bool) true ;
8695 bool result;
8696 PyObject * obj0 = 0 ;
8697 char *kwnames[] = {
8698 (char *) "doIt", NULL
8699 };
8700
8701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8702 if (obj0) {
8703 {
8704 arg1 = (bool)(SWIG_As_bool(obj0));
8705 if (SWIG_arg_fail(1)) SWIG_fail;
8706 }
8707 }
8708 {
8709 PyThreadState* __tstate = wxPyBeginAllowThreads();
8710 result = (bool)wxLog::EnableLogging(arg1);
8711
8712 wxPyEndAllowThreads(__tstate);
8713 if (PyErr_Occurred()) SWIG_fail;
8714 }
8715 {
8716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8717 }
8718 return resultobj;
8719 fail:
8720 return NULL;
8721 }
8722
8723
8724 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8725 PyObject *resultobj;
8726 wxLogLevel arg1 ;
8727 wxChar *arg2 = (wxChar *) 0 ;
8728 time_t arg3 ;
8729 PyObject * obj0 = 0 ;
8730 PyObject * obj1 = 0 ;
8731 PyObject * obj2 = 0 ;
8732 char *kwnames[] = {
8733 (char *) "level",(char *) "szString",(char *) "t", NULL
8734 };
8735
8736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8737 {
8738 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8739 if (SWIG_arg_fail(1)) SWIG_fail;
8740 }
8741 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8742 if (SWIG_arg_fail(2)) SWIG_fail;
8743 {
8744 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8745 if (SWIG_arg_fail(3)) SWIG_fail;
8746 }
8747 {
8748 PyThreadState* __tstate = wxPyBeginAllowThreads();
8749 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8750
8751 wxPyEndAllowThreads(__tstate);
8752 if (PyErr_Occurred()) SWIG_fail;
8753 }
8754 Py_INCREF(Py_None); resultobj = Py_None;
8755 return resultobj;
8756 fail:
8757 return NULL;
8758 }
8759
8760
8761 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8762 PyObject *resultobj;
8763 wxLog *arg1 = (wxLog *) 0 ;
8764 PyObject * obj0 = 0 ;
8765 char *kwnames[] = {
8766 (char *) "self", NULL
8767 };
8768
8769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8771 if (SWIG_arg_fail(1)) SWIG_fail;
8772 {
8773 PyThreadState* __tstate = wxPyBeginAllowThreads();
8774 (arg1)->Flush();
8775
8776 wxPyEndAllowThreads(__tstate);
8777 if (PyErr_Occurred()) SWIG_fail;
8778 }
8779 Py_INCREF(Py_None); resultobj = Py_None;
8780 return resultobj;
8781 fail:
8782 return NULL;
8783 }
8784
8785
8786 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8787 PyObject *resultobj;
8788 char *kwnames[] = {
8789 NULL
8790 };
8791
8792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8793 {
8794 PyThreadState* __tstate = wxPyBeginAllowThreads();
8795 wxLog::FlushActive();
8796
8797 wxPyEndAllowThreads(__tstate);
8798 if (PyErr_Occurred()) SWIG_fail;
8799 }
8800 Py_INCREF(Py_None); resultobj = Py_None;
8801 return resultobj;
8802 fail:
8803 return NULL;
8804 }
8805
8806
8807 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8808 PyObject *resultobj;
8809 wxLog *result;
8810 char *kwnames[] = {
8811 NULL
8812 };
8813
8814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8815 {
8816 PyThreadState* __tstate = wxPyBeginAllowThreads();
8817 result = (wxLog *)wxLog::GetActiveTarget();
8818
8819 wxPyEndAllowThreads(__tstate);
8820 if (PyErr_Occurred()) SWIG_fail;
8821 }
8822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8823 return resultobj;
8824 fail:
8825 return NULL;
8826 }
8827
8828
8829 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8830 PyObject *resultobj;
8831 wxLog *arg1 = (wxLog *) 0 ;
8832 wxLog *result;
8833 PyObject * obj0 = 0 ;
8834 char *kwnames[] = {
8835 (char *) "pLogger", NULL
8836 };
8837
8838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8840 if (SWIG_arg_fail(1)) SWIG_fail;
8841 {
8842 PyThreadState* __tstate = wxPyBeginAllowThreads();
8843 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8844
8845 wxPyEndAllowThreads(__tstate);
8846 if (PyErr_Occurred()) SWIG_fail;
8847 }
8848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8849 return resultobj;
8850 fail:
8851 return NULL;
8852 }
8853
8854
8855 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8856 PyObject *resultobj;
8857 char *kwnames[] = {
8858 NULL
8859 };
8860
8861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8862 {
8863 PyThreadState* __tstate = wxPyBeginAllowThreads();
8864 wxLog::Suspend();
8865
8866 wxPyEndAllowThreads(__tstate);
8867 if (PyErr_Occurred()) SWIG_fail;
8868 }
8869 Py_INCREF(Py_None); resultobj = Py_None;
8870 return resultobj;
8871 fail:
8872 return NULL;
8873 }
8874
8875
8876 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8877 PyObject *resultobj;
8878 char *kwnames[] = {
8879 NULL
8880 };
8881
8882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
8883 {
8884 PyThreadState* __tstate = wxPyBeginAllowThreads();
8885 wxLog::Resume();
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 *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
8898 PyObject *resultobj;
8899 bool arg1 = (bool) true ;
8900 PyObject * obj0 = 0 ;
8901 char *kwnames[] = {
8902 (char *) "bVerbose", NULL
8903 };
8904
8905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
8906 if (obj0) {
8907 {
8908 arg1 = (bool)(SWIG_As_bool(obj0));
8909 if (SWIG_arg_fail(1)) SWIG_fail;
8910 }
8911 }
8912 {
8913 PyThreadState* __tstate = wxPyBeginAllowThreads();
8914 wxLog::SetVerbose(arg1);
8915
8916 wxPyEndAllowThreads(__tstate);
8917 if (PyErr_Occurred()) SWIG_fail;
8918 }
8919 Py_INCREF(Py_None); resultobj = Py_None;
8920 return resultobj;
8921 fail:
8922 return NULL;
8923 }
8924
8925
8926 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
8927 PyObject *resultobj;
8928 wxLogLevel arg1 ;
8929 PyObject * obj0 = 0 ;
8930 char *kwnames[] = {
8931 (char *) "logLevel", NULL
8932 };
8933
8934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
8935 {
8936 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8937 if (SWIG_arg_fail(1)) SWIG_fail;
8938 }
8939 {
8940 PyThreadState* __tstate = wxPyBeginAllowThreads();
8941 wxLog::SetLogLevel(arg1);
8942
8943 wxPyEndAllowThreads(__tstate);
8944 if (PyErr_Occurred()) SWIG_fail;
8945 }
8946 Py_INCREF(Py_None); resultobj = Py_None;
8947 return resultobj;
8948 fail:
8949 return NULL;
8950 }
8951
8952
8953 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
8954 PyObject *resultobj;
8955 char *kwnames[] = {
8956 NULL
8957 };
8958
8959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
8960 {
8961 PyThreadState* __tstate = wxPyBeginAllowThreads();
8962 wxLog::DontCreateOnDemand();
8963
8964 wxPyEndAllowThreads(__tstate);
8965 if (PyErr_Occurred()) SWIG_fail;
8966 }
8967 Py_INCREF(Py_None); resultobj = Py_None;
8968 return resultobj;
8969 fail:
8970 return NULL;
8971 }
8972
8973
8974 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj;
8976 wxTraceMask arg1 ;
8977 PyObject * obj0 = 0 ;
8978 char *kwnames[] = {
8979 (char *) "ulMask", NULL
8980 };
8981
8982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
8983 {
8984 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
8985 if (SWIG_arg_fail(1)) SWIG_fail;
8986 }
8987 {
8988 PyThreadState* __tstate = wxPyBeginAllowThreads();
8989 wxLog::SetTraceMask(arg1);
8990
8991 wxPyEndAllowThreads(__tstate);
8992 if (PyErr_Occurred()) SWIG_fail;
8993 }
8994 Py_INCREF(Py_None); resultobj = Py_None;
8995 return resultobj;
8996 fail:
8997 return NULL;
8998 }
8999
9000
9001 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9002 PyObject *resultobj;
9003 wxString *arg1 = 0 ;
9004 bool temp1 = false ;
9005 PyObject * obj0 = 0 ;
9006 char *kwnames[] = {
9007 (char *) "str", NULL
9008 };
9009
9010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9011 {
9012 arg1 = wxString_in_helper(obj0);
9013 if (arg1 == NULL) SWIG_fail;
9014 temp1 = true;
9015 }
9016 {
9017 PyThreadState* __tstate = wxPyBeginAllowThreads();
9018 wxLog::AddTraceMask((wxString const &)*arg1);
9019
9020 wxPyEndAllowThreads(__tstate);
9021 if (PyErr_Occurred()) SWIG_fail;
9022 }
9023 Py_INCREF(Py_None); resultobj = Py_None;
9024 {
9025 if (temp1)
9026 delete arg1;
9027 }
9028 return resultobj;
9029 fail:
9030 {
9031 if (temp1)
9032 delete arg1;
9033 }
9034 return NULL;
9035 }
9036
9037
9038 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9039 PyObject *resultobj;
9040 wxString *arg1 = 0 ;
9041 bool temp1 = false ;
9042 PyObject * obj0 = 0 ;
9043 char *kwnames[] = {
9044 (char *) "str", NULL
9045 };
9046
9047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9048 {
9049 arg1 = wxString_in_helper(obj0);
9050 if (arg1 == NULL) SWIG_fail;
9051 temp1 = true;
9052 }
9053 {
9054 PyThreadState* __tstate = wxPyBeginAllowThreads();
9055 wxLog::RemoveTraceMask((wxString const &)*arg1);
9056
9057 wxPyEndAllowThreads(__tstate);
9058 if (PyErr_Occurred()) SWIG_fail;
9059 }
9060 Py_INCREF(Py_None); resultobj = Py_None;
9061 {
9062 if (temp1)
9063 delete arg1;
9064 }
9065 return resultobj;
9066 fail:
9067 {
9068 if (temp1)
9069 delete arg1;
9070 }
9071 return NULL;
9072 }
9073
9074
9075 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9076 PyObject *resultobj;
9077 char *kwnames[] = {
9078 NULL
9079 };
9080
9081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9082 {
9083 PyThreadState* __tstate = wxPyBeginAllowThreads();
9084 wxLog::ClearTraceMasks();
9085
9086 wxPyEndAllowThreads(__tstate);
9087 if (PyErr_Occurred()) SWIG_fail;
9088 }
9089 Py_INCREF(Py_None); resultobj = Py_None;
9090 return resultobj;
9091 fail:
9092 return NULL;
9093 }
9094
9095
9096 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9097 PyObject *resultobj;
9098 wxArrayString *result;
9099 char *kwnames[] = {
9100 NULL
9101 };
9102
9103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9104 {
9105 PyThreadState* __tstate = wxPyBeginAllowThreads();
9106 {
9107 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9108 result = (wxArrayString *) &_result_ref;
9109 }
9110
9111 wxPyEndAllowThreads(__tstate);
9112 if (PyErr_Occurred()) SWIG_fail;
9113 }
9114 {
9115 resultobj = wxArrayString2PyList_helper(*result);
9116 }
9117 return resultobj;
9118 fail:
9119 return NULL;
9120 }
9121
9122
9123 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9124 PyObject *resultobj;
9125 wxChar *arg1 = (wxChar *) 0 ;
9126 PyObject * obj0 = 0 ;
9127 char *kwnames[] = {
9128 (char *) "ts", NULL
9129 };
9130
9131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9133 if (SWIG_arg_fail(1)) SWIG_fail;
9134 {
9135 PyThreadState* __tstate = wxPyBeginAllowThreads();
9136 wxLog::SetTimestamp((wxChar const *)arg1);
9137
9138 wxPyEndAllowThreads(__tstate);
9139 if (PyErr_Occurred()) SWIG_fail;
9140 }
9141 Py_INCREF(Py_None); resultobj = Py_None;
9142 return resultobj;
9143 fail:
9144 return NULL;
9145 }
9146
9147
9148 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9149 PyObject *resultobj;
9150 bool result;
9151 char *kwnames[] = {
9152 NULL
9153 };
9154
9155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9156 {
9157 PyThreadState* __tstate = wxPyBeginAllowThreads();
9158 result = (bool)wxLog::GetVerbose();
9159
9160 wxPyEndAllowThreads(__tstate);
9161 if (PyErr_Occurred()) SWIG_fail;
9162 }
9163 {
9164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9165 }
9166 return resultobj;
9167 fail:
9168 return NULL;
9169 }
9170
9171
9172 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9173 PyObject *resultobj;
9174 wxTraceMask result;
9175 char *kwnames[] = {
9176 NULL
9177 };
9178
9179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9180 {
9181 PyThreadState* __tstate = wxPyBeginAllowThreads();
9182 result = (wxTraceMask)wxLog::GetTraceMask();
9183
9184 wxPyEndAllowThreads(__tstate);
9185 if (PyErr_Occurred()) SWIG_fail;
9186 }
9187 {
9188 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9189 }
9190 return resultobj;
9191 fail:
9192 return NULL;
9193 }
9194
9195
9196 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9197 PyObject *resultobj;
9198 wxChar *arg1 = (wxChar *) 0 ;
9199 bool result;
9200 PyObject * obj0 = 0 ;
9201 char *kwnames[] = {
9202 (char *) "mask", NULL
9203 };
9204
9205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9207 if (SWIG_arg_fail(1)) SWIG_fail;
9208 {
9209 PyThreadState* __tstate = wxPyBeginAllowThreads();
9210 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9211
9212 wxPyEndAllowThreads(__tstate);
9213 if (PyErr_Occurred()) SWIG_fail;
9214 }
9215 {
9216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9217 }
9218 return resultobj;
9219 fail:
9220 return NULL;
9221 }
9222
9223
9224 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9225 PyObject *resultobj;
9226 wxLogLevel result;
9227 char *kwnames[] = {
9228 NULL
9229 };
9230
9231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9232 {
9233 PyThreadState* __tstate = wxPyBeginAllowThreads();
9234 result = (wxLogLevel)wxLog::GetLogLevel();
9235
9236 wxPyEndAllowThreads(__tstate);
9237 if (PyErr_Occurred()) SWIG_fail;
9238 }
9239 {
9240 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9241 }
9242 return resultobj;
9243 fail:
9244 return NULL;
9245 }
9246
9247
9248 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9249 PyObject *resultobj;
9250 wxChar *result;
9251 char *kwnames[] = {
9252 NULL
9253 };
9254
9255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9256 {
9257 PyThreadState* __tstate = wxPyBeginAllowThreads();
9258 result = (wxChar *)wxLog::GetTimestamp();
9259
9260 wxPyEndAllowThreads(__tstate);
9261 if (PyErr_Occurred()) SWIG_fail;
9262 }
9263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9264 return resultobj;
9265 fail:
9266 return NULL;
9267 }
9268
9269
9270 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9271 PyObject *resultobj;
9272 wxString result;
9273 char *kwnames[] = {
9274 NULL
9275 };
9276
9277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9278 {
9279 PyThreadState* __tstate = wxPyBeginAllowThreads();
9280 result = Log_TimeStamp();
9281
9282 wxPyEndAllowThreads(__tstate);
9283 if (PyErr_Occurred()) SWIG_fail;
9284 }
9285 {
9286 #if wxUSE_UNICODE
9287 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9288 #else
9289 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9290 #endif
9291 }
9292 return resultobj;
9293 fail:
9294 return NULL;
9295 }
9296
9297
9298 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9299 PyObject *resultobj;
9300 wxLog *arg1 = (wxLog *) 0 ;
9301 PyObject * obj0 = 0 ;
9302 char *kwnames[] = {
9303 (char *) "self", NULL
9304 };
9305
9306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9308 if (SWIG_arg_fail(1)) SWIG_fail;
9309 {
9310 PyThreadState* __tstate = wxPyBeginAllowThreads();
9311 wxLog_Destroy(arg1);
9312
9313 wxPyEndAllowThreads(__tstate);
9314 if (PyErr_Occurred()) SWIG_fail;
9315 }
9316 Py_INCREF(Py_None); resultobj = Py_None;
9317 return resultobj;
9318 fail:
9319 return NULL;
9320 }
9321
9322
9323 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9324 PyObject *obj;
9325 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9326 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9327 Py_INCREF(obj);
9328 return Py_BuildValue((char *)"");
9329 }
9330 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9331 PyObject *resultobj;
9332 wxLogStderr *result;
9333 char *kwnames[] = {
9334 NULL
9335 };
9336
9337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9338 {
9339 PyThreadState* __tstate = wxPyBeginAllowThreads();
9340 result = (wxLogStderr *)new wxLogStderr();
9341
9342 wxPyEndAllowThreads(__tstate);
9343 if (PyErr_Occurred()) SWIG_fail;
9344 }
9345 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9346 return resultobj;
9347 fail:
9348 return NULL;
9349 }
9350
9351
9352 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9353 PyObject *obj;
9354 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9355 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9356 Py_INCREF(obj);
9357 return Py_BuildValue((char *)"");
9358 }
9359 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9360 PyObject *resultobj;
9361 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9362 wxLogTextCtrl *result;
9363 PyObject * obj0 = 0 ;
9364 char *kwnames[] = {
9365 (char *) "pTextCtrl", NULL
9366 };
9367
9368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9370 if (SWIG_arg_fail(1)) SWIG_fail;
9371 {
9372 PyThreadState* __tstate = wxPyBeginAllowThreads();
9373 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9374
9375 wxPyEndAllowThreads(__tstate);
9376 if (PyErr_Occurred()) SWIG_fail;
9377 }
9378 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9379 return resultobj;
9380 fail:
9381 return NULL;
9382 }
9383
9384
9385 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9386 PyObject *obj;
9387 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9388 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9389 Py_INCREF(obj);
9390 return Py_BuildValue((char *)"");
9391 }
9392 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9393 PyObject *resultobj;
9394 wxLogGui *result;
9395 char *kwnames[] = {
9396 NULL
9397 };
9398
9399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9400 {
9401 PyThreadState* __tstate = wxPyBeginAllowThreads();
9402 result = (wxLogGui *)new wxLogGui();
9403
9404 wxPyEndAllowThreads(__tstate);
9405 if (PyErr_Occurred()) SWIG_fail;
9406 }
9407 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9408 return resultobj;
9409 fail:
9410 return NULL;
9411 }
9412
9413
9414 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9415 PyObject *obj;
9416 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9417 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9418 Py_INCREF(obj);
9419 return Py_BuildValue((char *)"");
9420 }
9421 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9422 PyObject *resultobj;
9423 wxFrame *arg1 = (wxFrame *) 0 ;
9424 wxString *arg2 = 0 ;
9425 bool arg3 = (bool) true ;
9426 bool arg4 = (bool) true ;
9427 wxLogWindow *result;
9428 bool temp2 = false ;
9429 PyObject * obj0 = 0 ;
9430 PyObject * obj1 = 0 ;
9431 PyObject * obj2 = 0 ;
9432 PyObject * obj3 = 0 ;
9433 char *kwnames[] = {
9434 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9435 };
9436
9437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9439 if (SWIG_arg_fail(1)) SWIG_fail;
9440 {
9441 arg2 = wxString_in_helper(obj1);
9442 if (arg2 == NULL) SWIG_fail;
9443 temp2 = true;
9444 }
9445 if (obj2) {
9446 {
9447 arg3 = (bool)(SWIG_As_bool(obj2));
9448 if (SWIG_arg_fail(3)) SWIG_fail;
9449 }
9450 }
9451 if (obj3) {
9452 {
9453 arg4 = (bool)(SWIG_As_bool(obj3));
9454 if (SWIG_arg_fail(4)) SWIG_fail;
9455 }
9456 }
9457 {
9458 PyThreadState* __tstate = wxPyBeginAllowThreads();
9459 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9460
9461 wxPyEndAllowThreads(__tstate);
9462 if (PyErr_Occurred()) SWIG_fail;
9463 }
9464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9465 {
9466 if (temp2)
9467 delete arg2;
9468 }
9469 return resultobj;
9470 fail:
9471 {
9472 if (temp2)
9473 delete arg2;
9474 }
9475 return NULL;
9476 }
9477
9478
9479 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9480 PyObject *resultobj;
9481 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9482 bool arg2 = (bool) true ;
9483 PyObject * obj0 = 0 ;
9484 PyObject * obj1 = 0 ;
9485 char *kwnames[] = {
9486 (char *) "self",(char *) "bShow", NULL
9487 };
9488
9489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9491 if (SWIG_arg_fail(1)) SWIG_fail;
9492 if (obj1) {
9493 {
9494 arg2 = (bool)(SWIG_As_bool(obj1));
9495 if (SWIG_arg_fail(2)) SWIG_fail;
9496 }
9497 }
9498 {
9499 PyThreadState* __tstate = wxPyBeginAllowThreads();
9500 (arg1)->Show(arg2);
9501
9502 wxPyEndAllowThreads(__tstate);
9503 if (PyErr_Occurred()) SWIG_fail;
9504 }
9505 Py_INCREF(Py_None); resultobj = Py_None;
9506 return resultobj;
9507 fail:
9508 return NULL;
9509 }
9510
9511
9512 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9513 PyObject *resultobj;
9514 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9515 wxFrame *result;
9516 PyObject * obj0 = 0 ;
9517 char *kwnames[] = {
9518 (char *) "self", NULL
9519 };
9520
9521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9523 if (SWIG_arg_fail(1)) SWIG_fail;
9524 {
9525 PyThreadState* __tstate = wxPyBeginAllowThreads();
9526 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9527
9528 wxPyEndAllowThreads(__tstate);
9529 if (PyErr_Occurred()) SWIG_fail;
9530 }
9531 {
9532 resultobj = wxPyMake_wxObject(result, 0);
9533 }
9534 return resultobj;
9535 fail:
9536 return NULL;
9537 }
9538
9539
9540 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9541 PyObject *resultobj;
9542 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9543 wxLog *result;
9544 PyObject * obj0 = 0 ;
9545 char *kwnames[] = {
9546 (char *) "self", NULL
9547 };
9548
9549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9551 if (SWIG_arg_fail(1)) SWIG_fail;
9552 {
9553 PyThreadState* __tstate = wxPyBeginAllowThreads();
9554 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9555
9556 wxPyEndAllowThreads(__tstate);
9557 if (PyErr_Occurred()) SWIG_fail;
9558 }
9559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9560 return resultobj;
9561 fail:
9562 return NULL;
9563 }
9564
9565
9566 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9567 PyObject *resultobj;
9568 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9569 bool result;
9570 PyObject * obj0 = 0 ;
9571 char *kwnames[] = {
9572 (char *) "self", NULL
9573 };
9574
9575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9577 if (SWIG_arg_fail(1)) SWIG_fail;
9578 {
9579 PyThreadState* __tstate = wxPyBeginAllowThreads();
9580 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9581
9582 wxPyEndAllowThreads(__tstate);
9583 if (PyErr_Occurred()) SWIG_fail;
9584 }
9585 {
9586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9587 }
9588 return resultobj;
9589 fail:
9590 return NULL;
9591 }
9592
9593
9594 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9595 PyObject *resultobj;
9596 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9597 bool arg2 ;
9598 PyObject * obj0 = 0 ;
9599 PyObject * obj1 = 0 ;
9600 char *kwnames[] = {
9601 (char *) "self",(char *) "bDoPass", NULL
9602 };
9603
9604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9606 if (SWIG_arg_fail(1)) SWIG_fail;
9607 {
9608 arg2 = (bool)(SWIG_As_bool(obj1));
9609 if (SWIG_arg_fail(2)) SWIG_fail;
9610 }
9611 {
9612 PyThreadState* __tstate = wxPyBeginAllowThreads();
9613 (arg1)->PassMessages(arg2);
9614
9615 wxPyEndAllowThreads(__tstate);
9616 if (PyErr_Occurred()) SWIG_fail;
9617 }
9618 Py_INCREF(Py_None); resultobj = Py_None;
9619 return resultobj;
9620 fail:
9621 return NULL;
9622 }
9623
9624
9625 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9626 PyObject *obj;
9627 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9628 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9629 Py_INCREF(obj);
9630 return Py_BuildValue((char *)"");
9631 }
9632 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9633 PyObject *resultobj;
9634 wxLog *arg1 = (wxLog *) 0 ;
9635 wxLogChain *result;
9636 PyObject * obj0 = 0 ;
9637 char *kwnames[] = {
9638 (char *) "logger", NULL
9639 };
9640
9641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9643 if (SWIG_arg_fail(1)) SWIG_fail;
9644 {
9645 PyThreadState* __tstate = wxPyBeginAllowThreads();
9646 result = (wxLogChain *)new wxLogChain(arg1);
9647
9648 wxPyEndAllowThreads(__tstate);
9649 if (PyErr_Occurred()) SWIG_fail;
9650 }
9651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9652 return resultobj;
9653 fail:
9654 return NULL;
9655 }
9656
9657
9658 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9659 PyObject *resultobj;
9660 wxLogChain *arg1 = (wxLogChain *) 0 ;
9661 wxLog *arg2 = (wxLog *) 0 ;
9662 PyObject * obj0 = 0 ;
9663 PyObject * obj1 = 0 ;
9664 char *kwnames[] = {
9665 (char *) "self",(char *) "logger", NULL
9666 };
9667
9668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9670 if (SWIG_arg_fail(1)) SWIG_fail;
9671 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9672 if (SWIG_arg_fail(2)) SWIG_fail;
9673 {
9674 PyThreadState* __tstate = wxPyBeginAllowThreads();
9675 (arg1)->SetLog(arg2);
9676
9677 wxPyEndAllowThreads(__tstate);
9678 if (PyErr_Occurred()) SWIG_fail;
9679 }
9680 Py_INCREF(Py_None); resultobj = Py_None;
9681 return resultobj;
9682 fail:
9683 return NULL;
9684 }
9685
9686
9687 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9688 PyObject *resultobj;
9689 wxLogChain *arg1 = (wxLogChain *) 0 ;
9690 bool arg2 ;
9691 PyObject * obj0 = 0 ;
9692 PyObject * obj1 = 0 ;
9693 char *kwnames[] = {
9694 (char *) "self",(char *) "bDoPass", NULL
9695 };
9696
9697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9699 if (SWIG_arg_fail(1)) SWIG_fail;
9700 {
9701 arg2 = (bool)(SWIG_As_bool(obj1));
9702 if (SWIG_arg_fail(2)) SWIG_fail;
9703 }
9704 {
9705 PyThreadState* __tstate = wxPyBeginAllowThreads();
9706 (arg1)->PassMessages(arg2);
9707
9708 wxPyEndAllowThreads(__tstate);
9709 if (PyErr_Occurred()) SWIG_fail;
9710 }
9711 Py_INCREF(Py_None); resultobj = Py_None;
9712 return resultobj;
9713 fail:
9714 return NULL;
9715 }
9716
9717
9718 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9719 PyObject *resultobj;
9720 wxLogChain *arg1 = (wxLogChain *) 0 ;
9721 bool result;
9722 PyObject * obj0 = 0 ;
9723 char *kwnames[] = {
9724 (char *) "self", NULL
9725 };
9726
9727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9729 if (SWIG_arg_fail(1)) SWIG_fail;
9730 {
9731 PyThreadState* __tstate = wxPyBeginAllowThreads();
9732 result = (bool)(arg1)->IsPassingMessages();
9733
9734 wxPyEndAllowThreads(__tstate);
9735 if (PyErr_Occurred()) SWIG_fail;
9736 }
9737 {
9738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9739 }
9740 return resultobj;
9741 fail:
9742 return NULL;
9743 }
9744
9745
9746 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9747 PyObject *resultobj;
9748 wxLogChain *arg1 = (wxLogChain *) 0 ;
9749 wxLog *result;
9750 PyObject * obj0 = 0 ;
9751 char *kwnames[] = {
9752 (char *) "self", NULL
9753 };
9754
9755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9757 if (SWIG_arg_fail(1)) SWIG_fail;
9758 {
9759 PyThreadState* __tstate = wxPyBeginAllowThreads();
9760 result = (wxLog *)(arg1)->GetOldLog();
9761
9762 wxPyEndAllowThreads(__tstate);
9763 if (PyErr_Occurred()) SWIG_fail;
9764 }
9765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9766 return resultobj;
9767 fail:
9768 return NULL;
9769 }
9770
9771
9772 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9773 PyObject *obj;
9774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9775 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9776 Py_INCREF(obj);
9777 return Py_BuildValue((char *)"");
9778 }
9779 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9780 PyObject *resultobj;
9781 unsigned long result;
9782 char *kwnames[] = {
9783 NULL
9784 };
9785
9786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9787 {
9788 PyThreadState* __tstate = wxPyBeginAllowThreads();
9789 result = (unsigned long)wxSysErrorCode();
9790
9791 wxPyEndAllowThreads(__tstate);
9792 if (PyErr_Occurred()) SWIG_fail;
9793 }
9794 {
9795 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9796 }
9797 return resultobj;
9798 fail:
9799 return NULL;
9800 }
9801
9802
9803 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9804 PyObject *resultobj;
9805 unsigned long arg1 = (unsigned long) 0 ;
9806 wxString result;
9807 PyObject * obj0 = 0 ;
9808 char *kwnames[] = {
9809 (char *) "nErrCode", NULL
9810 };
9811
9812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9813 if (obj0) {
9814 {
9815 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9816 if (SWIG_arg_fail(1)) SWIG_fail;
9817 }
9818 }
9819 {
9820 PyThreadState* __tstate = wxPyBeginAllowThreads();
9821 result = wxSysErrorMsg(arg1);
9822
9823 wxPyEndAllowThreads(__tstate);
9824 if (PyErr_Occurred()) SWIG_fail;
9825 }
9826 {
9827 #if wxUSE_UNICODE
9828 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9829 #else
9830 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9831 #endif
9832 }
9833 return resultobj;
9834 fail:
9835 return NULL;
9836 }
9837
9838
9839 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9840 PyObject *resultobj;
9841 wxString *arg1 = 0 ;
9842 bool temp1 = false ;
9843 PyObject * obj0 = 0 ;
9844 char *kwnames[] = {
9845 (char *) "msg", NULL
9846 };
9847
9848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9849 {
9850 arg1 = wxString_in_helper(obj0);
9851 if (arg1 == NULL) SWIG_fail;
9852 temp1 = true;
9853 }
9854 {
9855 PyThreadState* __tstate = wxPyBeginAllowThreads();
9856 wxPyLogFatalError((wxString const &)*arg1);
9857
9858 wxPyEndAllowThreads(__tstate);
9859 if (PyErr_Occurred()) SWIG_fail;
9860 }
9861 Py_INCREF(Py_None); resultobj = Py_None;
9862 {
9863 if (temp1)
9864 delete arg1;
9865 }
9866 return resultobj;
9867 fail:
9868 {
9869 if (temp1)
9870 delete arg1;
9871 }
9872 return NULL;
9873 }
9874
9875
9876 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
9877 PyObject *resultobj;
9878 wxString *arg1 = 0 ;
9879 bool temp1 = false ;
9880 PyObject * obj0 = 0 ;
9881 char *kwnames[] = {
9882 (char *) "msg", NULL
9883 };
9884
9885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
9886 {
9887 arg1 = wxString_in_helper(obj0);
9888 if (arg1 == NULL) SWIG_fail;
9889 temp1 = true;
9890 }
9891 {
9892 PyThreadState* __tstate = wxPyBeginAllowThreads();
9893 wxPyLogError((wxString const &)*arg1);
9894
9895 wxPyEndAllowThreads(__tstate);
9896 if (PyErr_Occurred()) SWIG_fail;
9897 }
9898 Py_INCREF(Py_None); resultobj = Py_None;
9899 {
9900 if (temp1)
9901 delete arg1;
9902 }
9903 return resultobj;
9904 fail:
9905 {
9906 if (temp1)
9907 delete arg1;
9908 }
9909 return NULL;
9910 }
9911
9912
9913 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
9914 PyObject *resultobj;
9915 wxString *arg1 = 0 ;
9916 bool temp1 = false ;
9917 PyObject * obj0 = 0 ;
9918 char *kwnames[] = {
9919 (char *) "msg", NULL
9920 };
9921
9922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
9923 {
9924 arg1 = wxString_in_helper(obj0);
9925 if (arg1 == NULL) SWIG_fail;
9926 temp1 = true;
9927 }
9928 {
9929 PyThreadState* __tstate = wxPyBeginAllowThreads();
9930 wxPyLogWarning((wxString const &)*arg1);
9931
9932 wxPyEndAllowThreads(__tstate);
9933 if (PyErr_Occurred()) SWIG_fail;
9934 }
9935 Py_INCREF(Py_None); resultobj = Py_None;
9936 {
9937 if (temp1)
9938 delete arg1;
9939 }
9940 return resultobj;
9941 fail:
9942 {
9943 if (temp1)
9944 delete arg1;
9945 }
9946 return NULL;
9947 }
9948
9949
9950 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9951 PyObject *resultobj;
9952 wxString *arg1 = 0 ;
9953 bool temp1 = false ;
9954 PyObject * obj0 = 0 ;
9955 char *kwnames[] = {
9956 (char *) "msg", NULL
9957 };
9958
9959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
9960 {
9961 arg1 = wxString_in_helper(obj0);
9962 if (arg1 == NULL) SWIG_fail;
9963 temp1 = true;
9964 }
9965 {
9966 PyThreadState* __tstate = wxPyBeginAllowThreads();
9967 wxPyLogMessage((wxString const &)*arg1);
9968
9969 wxPyEndAllowThreads(__tstate);
9970 if (PyErr_Occurred()) SWIG_fail;
9971 }
9972 Py_INCREF(Py_None); resultobj = Py_None;
9973 {
9974 if (temp1)
9975 delete arg1;
9976 }
9977 return resultobj;
9978 fail:
9979 {
9980 if (temp1)
9981 delete arg1;
9982 }
9983 return NULL;
9984 }
9985
9986
9987 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9988 PyObject *resultobj;
9989 wxString *arg1 = 0 ;
9990 bool temp1 = false ;
9991 PyObject * obj0 = 0 ;
9992 char *kwnames[] = {
9993 (char *) "msg", NULL
9994 };
9995
9996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
9997 {
9998 arg1 = wxString_in_helper(obj0);
9999 if (arg1 == NULL) SWIG_fail;
10000 temp1 = true;
10001 }
10002 {
10003 PyThreadState* __tstate = wxPyBeginAllowThreads();
10004 wxPyLogInfo((wxString const &)*arg1);
10005
10006 wxPyEndAllowThreads(__tstate);
10007 if (PyErr_Occurred()) SWIG_fail;
10008 }
10009 Py_INCREF(Py_None); resultobj = Py_None;
10010 {
10011 if (temp1)
10012 delete arg1;
10013 }
10014 return resultobj;
10015 fail:
10016 {
10017 if (temp1)
10018 delete arg1;
10019 }
10020 return NULL;
10021 }
10022
10023
10024 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10025 PyObject *resultobj;
10026 wxString *arg1 = 0 ;
10027 bool temp1 = false ;
10028 PyObject * obj0 = 0 ;
10029 char *kwnames[] = {
10030 (char *) "msg", NULL
10031 };
10032
10033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10034 {
10035 arg1 = wxString_in_helper(obj0);
10036 if (arg1 == NULL) SWIG_fail;
10037 temp1 = true;
10038 }
10039 {
10040 PyThreadState* __tstate = wxPyBeginAllowThreads();
10041 wxPyLogDebug((wxString const &)*arg1);
10042
10043 wxPyEndAllowThreads(__tstate);
10044 if (PyErr_Occurred()) SWIG_fail;
10045 }
10046 Py_INCREF(Py_None); resultobj = Py_None;
10047 {
10048 if (temp1)
10049 delete arg1;
10050 }
10051 return resultobj;
10052 fail:
10053 {
10054 if (temp1)
10055 delete arg1;
10056 }
10057 return NULL;
10058 }
10059
10060
10061 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10062 PyObject *resultobj;
10063 wxString *arg1 = 0 ;
10064 bool temp1 = false ;
10065 PyObject * obj0 = 0 ;
10066 char *kwnames[] = {
10067 (char *) "msg", NULL
10068 };
10069
10070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10071 {
10072 arg1 = wxString_in_helper(obj0);
10073 if (arg1 == NULL) SWIG_fail;
10074 temp1 = true;
10075 }
10076 {
10077 PyThreadState* __tstate = wxPyBeginAllowThreads();
10078 wxPyLogVerbose((wxString const &)*arg1);
10079
10080 wxPyEndAllowThreads(__tstate);
10081 if (PyErr_Occurred()) SWIG_fail;
10082 }
10083 Py_INCREF(Py_None); resultobj = Py_None;
10084 {
10085 if (temp1)
10086 delete arg1;
10087 }
10088 return resultobj;
10089 fail:
10090 {
10091 if (temp1)
10092 delete arg1;
10093 }
10094 return NULL;
10095 }
10096
10097
10098 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10099 PyObject *resultobj;
10100 wxString *arg1 = 0 ;
10101 bool temp1 = false ;
10102 PyObject * obj0 = 0 ;
10103 char *kwnames[] = {
10104 (char *) "msg", NULL
10105 };
10106
10107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10108 {
10109 arg1 = wxString_in_helper(obj0);
10110 if (arg1 == NULL) SWIG_fail;
10111 temp1 = true;
10112 }
10113 {
10114 PyThreadState* __tstate = wxPyBeginAllowThreads();
10115 wxPyLogStatus((wxString const &)*arg1);
10116
10117 wxPyEndAllowThreads(__tstate);
10118 if (PyErr_Occurred()) SWIG_fail;
10119 }
10120 Py_INCREF(Py_None); resultobj = Py_None;
10121 {
10122 if (temp1)
10123 delete arg1;
10124 }
10125 return resultobj;
10126 fail:
10127 {
10128 if (temp1)
10129 delete arg1;
10130 }
10131 return NULL;
10132 }
10133
10134
10135 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10136 PyObject *resultobj;
10137 wxFrame *arg1 = (wxFrame *) 0 ;
10138 wxString *arg2 = 0 ;
10139 bool temp2 = false ;
10140 PyObject * obj0 = 0 ;
10141 PyObject * obj1 = 0 ;
10142 char *kwnames[] = {
10143 (char *) "pFrame",(char *) "msg", NULL
10144 };
10145
10146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10148 if (SWIG_arg_fail(1)) SWIG_fail;
10149 {
10150 arg2 = wxString_in_helper(obj1);
10151 if (arg2 == NULL) SWIG_fail;
10152 temp2 = true;
10153 }
10154 {
10155 PyThreadState* __tstate = wxPyBeginAllowThreads();
10156 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10157
10158 wxPyEndAllowThreads(__tstate);
10159 if (PyErr_Occurred()) SWIG_fail;
10160 }
10161 Py_INCREF(Py_None); resultobj = Py_None;
10162 {
10163 if (temp2)
10164 delete arg2;
10165 }
10166 return resultobj;
10167 fail:
10168 {
10169 if (temp2)
10170 delete arg2;
10171 }
10172 return NULL;
10173 }
10174
10175
10176 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10177 PyObject *resultobj;
10178 wxString *arg1 = 0 ;
10179 bool temp1 = false ;
10180 PyObject * obj0 = 0 ;
10181 char *kwnames[] = {
10182 (char *) "msg", NULL
10183 };
10184
10185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10186 {
10187 arg1 = wxString_in_helper(obj0);
10188 if (arg1 == NULL) SWIG_fail;
10189 temp1 = true;
10190 }
10191 {
10192 PyThreadState* __tstate = wxPyBeginAllowThreads();
10193 wxPyLogSysError((wxString const &)*arg1);
10194
10195 wxPyEndAllowThreads(__tstate);
10196 if (PyErr_Occurred()) SWIG_fail;
10197 }
10198 Py_INCREF(Py_None); resultobj = Py_None;
10199 {
10200 if (temp1)
10201 delete arg1;
10202 }
10203 return resultobj;
10204 fail:
10205 {
10206 if (temp1)
10207 delete arg1;
10208 }
10209 return NULL;
10210 }
10211
10212
10213 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10214 PyObject *resultobj;
10215 unsigned long arg1 ;
10216 wxString *arg2 = 0 ;
10217 bool temp2 = false ;
10218 PyObject * obj0 = 0 ;
10219 PyObject * obj1 = 0 ;
10220 char *kwnames[] = {
10221 (char *) "level",(char *) "msg", NULL
10222 };
10223
10224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10225 {
10226 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10227 if (SWIG_arg_fail(1)) SWIG_fail;
10228 }
10229 {
10230 arg2 = wxString_in_helper(obj1);
10231 if (arg2 == NULL) SWIG_fail;
10232 temp2 = true;
10233 }
10234 {
10235 PyThreadState* __tstate = wxPyBeginAllowThreads();
10236 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10237
10238 wxPyEndAllowThreads(__tstate);
10239 if (PyErr_Occurred()) SWIG_fail;
10240 }
10241 Py_INCREF(Py_None); resultobj = Py_None;
10242 {
10243 if (temp2)
10244 delete arg2;
10245 }
10246 return resultobj;
10247 fail:
10248 {
10249 if (temp2)
10250 delete arg2;
10251 }
10252 return NULL;
10253 }
10254
10255
10256 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10257 PyObject *resultobj;
10258 unsigned long arg1 ;
10259 wxString *arg2 = 0 ;
10260 bool temp2 = false ;
10261 PyObject * obj0 = 0 ;
10262 PyObject * obj1 = 0 ;
10263
10264 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10265 {
10266 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10267 if (SWIG_arg_fail(1)) SWIG_fail;
10268 }
10269 {
10270 arg2 = wxString_in_helper(obj1);
10271 if (arg2 == NULL) SWIG_fail;
10272 temp2 = true;
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 wxPyLogTrace(arg1,(wxString const &)*arg2);
10277
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 Py_INCREF(Py_None); resultobj = Py_None;
10282 {
10283 if (temp2)
10284 delete arg2;
10285 }
10286 return resultobj;
10287 fail:
10288 {
10289 if (temp2)
10290 delete arg2;
10291 }
10292 return NULL;
10293 }
10294
10295
10296 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10297 PyObject *resultobj;
10298 wxString *arg1 = 0 ;
10299 wxString *arg2 = 0 ;
10300 bool temp1 = false ;
10301 bool temp2 = false ;
10302 PyObject * obj0 = 0 ;
10303 PyObject * obj1 = 0 ;
10304
10305 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10306 {
10307 arg1 = wxString_in_helper(obj0);
10308 if (arg1 == NULL) SWIG_fail;
10309 temp1 = true;
10310 }
10311 {
10312 arg2 = wxString_in_helper(obj1);
10313 if (arg2 == NULL) SWIG_fail;
10314 temp2 = true;
10315 }
10316 {
10317 PyThreadState* __tstate = wxPyBeginAllowThreads();
10318 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10319
10320 wxPyEndAllowThreads(__tstate);
10321 if (PyErr_Occurred()) SWIG_fail;
10322 }
10323 Py_INCREF(Py_None); resultobj = Py_None;
10324 {
10325 if (temp1)
10326 delete arg1;
10327 }
10328 {
10329 if (temp2)
10330 delete arg2;
10331 }
10332 return resultobj;
10333 fail:
10334 {
10335 if (temp1)
10336 delete arg1;
10337 }
10338 {
10339 if (temp2)
10340 delete arg2;
10341 }
10342 return NULL;
10343 }
10344
10345
10346 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10347 int argc;
10348 PyObject *argv[3];
10349 int ii;
10350
10351 argc = PyObject_Length(args);
10352 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10353 argv[ii] = PyTuple_GetItem(args,ii);
10354 }
10355 if (argc == 2) {
10356 int _v;
10357 {
10358 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10359 }
10360 if (_v) {
10361 {
10362 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10363 }
10364 if (_v) {
10365 return _wrap_LogTrace__SWIG_1(self,args);
10366 }
10367 }
10368 }
10369 if (argc == 2) {
10370 int _v;
10371 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10372 if (_v) {
10373 {
10374 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10375 }
10376 if (_v) {
10377 return _wrap_LogTrace__SWIG_0(self,args);
10378 }
10379 }
10380 }
10381
10382 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10383 return NULL;
10384 }
10385
10386
10387 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10388 PyObject *resultobj;
10389 wxString *arg1 = 0 ;
10390 wxString *arg2 = 0 ;
10391 bool temp1 = false ;
10392 bool temp2 = false ;
10393 PyObject * obj0 = 0 ;
10394 PyObject * obj1 = 0 ;
10395 char *kwnames[] = {
10396 (char *) "title",(char *) "text", NULL
10397 };
10398
10399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10400 {
10401 arg1 = wxString_in_helper(obj0);
10402 if (arg1 == NULL) SWIG_fail;
10403 temp1 = true;
10404 }
10405 {
10406 arg2 = wxString_in_helper(obj1);
10407 if (arg2 == NULL) SWIG_fail;
10408 temp2 = true;
10409 }
10410 {
10411 PyThreadState* __tstate = wxPyBeginAllowThreads();
10412 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10413
10414 wxPyEndAllowThreads(__tstate);
10415 if (PyErr_Occurred()) SWIG_fail;
10416 }
10417 Py_INCREF(Py_None); resultobj = Py_None;
10418 {
10419 if (temp1)
10420 delete arg1;
10421 }
10422 {
10423 if (temp2)
10424 delete arg2;
10425 }
10426 return resultobj;
10427 fail:
10428 {
10429 if (temp1)
10430 delete arg1;
10431 }
10432 {
10433 if (temp2)
10434 delete arg2;
10435 }
10436 return NULL;
10437 }
10438
10439
10440 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10441 PyObject *resultobj;
10442 wxLogNull *result;
10443 char *kwnames[] = {
10444 NULL
10445 };
10446
10447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10448 {
10449 PyThreadState* __tstate = wxPyBeginAllowThreads();
10450 result = (wxLogNull *)new wxLogNull();
10451
10452 wxPyEndAllowThreads(__tstate);
10453 if (PyErr_Occurred()) SWIG_fail;
10454 }
10455 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10456 return resultobj;
10457 fail:
10458 return NULL;
10459 }
10460
10461
10462 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10463 PyObject *resultobj;
10464 wxLogNull *arg1 = (wxLogNull *) 0 ;
10465 PyObject * obj0 = 0 ;
10466 char *kwnames[] = {
10467 (char *) "self", NULL
10468 };
10469
10470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10472 if (SWIG_arg_fail(1)) SWIG_fail;
10473 {
10474 PyThreadState* __tstate = wxPyBeginAllowThreads();
10475 delete arg1;
10476
10477 wxPyEndAllowThreads(__tstate);
10478 if (PyErr_Occurred()) SWIG_fail;
10479 }
10480 Py_INCREF(Py_None); resultobj = Py_None;
10481 return resultobj;
10482 fail:
10483 return NULL;
10484 }
10485
10486
10487 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10488 PyObject *obj;
10489 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10490 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10491 Py_INCREF(obj);
10492 return Py_BuildValue((char *)"");
10493 }
10494 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10495 PyObject *resultobj;
10496 wxPyLog *result;
10497 char *kwnames[] = {
10498 NULL
10499 };
10500
10501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10502 {
10503 PyThreadState* __tstate = wxPyBeginAllowThreads();
10504 result = (wxPyLog *)new wxPyLog();
10505
10506 wxPyEndAllowThreads(__tstate);
10507 if (PyErr_Occurred()) SWIG_fail;
10508 }
10509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10510 return resultobj;
10511 fail:
10512 return NULL;
10513 }
10514
10515
10516 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10517 PyObject *resultobj;
10518 wxPyLog *arg1 = (wxPyLog *) 0 ;
10519 PyObject *arg2 = (PyObject *) 0 ;
10520 PyObject *arg3 = (PyObject *) 0 ;
10521 PyObject * obj0 = 0 ;
10522 PyObject * obj1 = 0 ;
10523 PyObject * obj2 = 0 ;
10524 char *kwnames[] = {
10525 (char *) "self",(char *) "self",(char *) "_class", NULL
10526 };
10527
10528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10530 if (SWIG_arg_fail(1)) SWIG_fail;
10531 arg2 = obj1;
10532 arg3 = obj2;
10533 {
10534 PyThreadState* __tstate = wxPyBeginAllowThreads();
10535 (arg1)->_setCallbackInfo(arg2,arg3);
10536
10537 wxPyEndAllowThreads(__tstate);
10538 if (PyErr_Occurred()) SWIG_fail;
10539 }
10540 Py_INCREF(Py_None); resultobj = Py_None;
10541 return resultobj;
10542 fail:
10543 return NULL;
10544 }
10545
10546
10547 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10548 PyObject *obj;
10549 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10550 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10551 Py_INCREF(obj);
10552 return Py_BuildValue((char *)"");
10553 }
10554 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10555 PyObject *resultobj;
10556 int arg1 ;
10557 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10558 int arg3 = (int) wxKILL_NOCHILDREN ;
10559 wxKillError result;
10560 PyObject * obj0 = 0 ;
10561 PyObject * obj1 = 0 ;
10562 PyObject * obj2 = 0 ;
10563 char *kwnames[] = {
10564 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10565 };
10566
10567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10568 {
10569 arg1 = (int)(SWIG_As_int(obj0));
10570 if (SWIG_arg_fail(1)) SWIG_fail;
10571 }
10572 if (obj1) {
10573 {
10574 arg2 = (wxSignal)(SWIG_As_int(obj1));
10575 if (SWIG_arg_fail(2)) SWIG_fail;
10576 }
10577 }
10578 if (obj2) {
10579 {
10580 arg3 = (int)(SWIG_As_int(obj2));
10581 if (SWIG_arg_fail(3)) SWIG_fail;
10582 }
10583 }
10584 {
10585 PyThreadState* __tstate = wxPyBeginAllowThreads();
10586 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10587
10588 wxPyEndAllowThreads(__tstate);
10589 if (PyErr_Occurred()) SWIG_fail;
10590 }
10591 resultobj = SWIG_From_int((result));
10592 return resultobj;
10593 fail:
10594 return NULL;
10595 }
10596
10597
10598 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10599 PyObject *resultobj;
10600 int arg1 ;
10601 bool result;
10602 PyObject * obj0 = 0 ;
10603 char *kwnames[] = {
10604 (char *) "pid", NULL
10605 };
10606
10607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10608 {
10609 arg1 = (int)(SWIG_As_int(obj0));
10610 if (SWIG_arg_fail(1)) SWIG_fail;
10611 }
10612 {
10613 PyThreadState* __tstate = wxPyBeginAllowThreads();
10614 result = (bool)wxPyProcess::Exists(arg1);
10615
10616 wxPyEndAllowThreads(__tstate);
10617 if (PyErr_Occurred()) SWIG_fail;
10618 }
10619 {
10620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10621 }
10622 return resultobj;
10623 fail:
10624 return NULL;
10625 }
10626
10627
10628 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10629 PyObject *resultobj;
10630 wxString *arg1 = 0 ;
10631 int arg2 = (int) wxEXEC_ASYNC ;
10632 wxPyProcess *result;
10633 bool temp1 = false ;
10634 PyObject * obj0 = 0 ;
10635 PyObject * obj1 = 0 ;
10636 char *kwnames[] = {
10637 (char *) "cmd",(char *) "flags", NULL
10638 };
10639
10640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10641 {
10642 arg1 = wxString_in_helper(obj0);
10643 if (arg1 == NULL) SWIG_fail;
10644 temp1 = true;
10645 }
10646 if (obj1) {
10647 {
10648 arg2 = (int)(SWIG_As_int(obj1));
10649 if (SWIG_arg_fail(2)) SWIG_fail;
10650 }
10651 }
10652 {
10653 PyThreadState* __tstate = wxPyBeginAllowThreads();
10654 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10655
10656 wxPyEndAllowThreads(__tstate);
10657 if (PyErr_Occurred()) SWIG_fail;
10658 }
10659 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10660 {
10661 if (temp1)
10662 delete arg1;
10663 }
10664 return resultobj;
10665 fail:
10666 {
10667 if (temp1)
10668 delete arg1;
10669 }
10670 return NULL;
10671 }
10672
10673
10674 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10675 PyObject *resultobj;
10676 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10677 int arg2 = (int) -1 ;
10678 wxPyProcess *result;
10679 PyObject * obj0 = 0 ;
10680 PyObject * obj1 = 0 ;
10681 char *kwnames[] = {
10682 (char *) "parent",(char *) "id", NULL
10683 };
10684
10685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10686 if (obj0) {
10687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10688 if (SWIG_arg_fail(1)) SWIG_fail;
10689 }
10690 if (obj1) {
10691 {
10692 arg2 = (int)(SWIG_As_int(obj1));
10693 if (SWIG_arg_fail(2)) SWIG_fail;
10694 }
10695 }
10696 {
10697 PyThreadState* __tstate = wxPyBeginAllowThreads();
10698 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10699
10700 wxPyEndAllowThreads(__tstate);
10701 if (PyErr_Occurred()) SWIG_fail;
10702 }
10703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10704 return resultobj;
10705 fail:
10706 return NULL;
10707 }
10708
10709
10710 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10711 PyObject *resultobj;
10712 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10713 PyObject *arg2 = (PyObject *) 0 ;
10714 PyObject *arg3 = (PyObject *) 0 ;
10715 PyObject * obj0 = 0 ;
10716 PyObject * obj1 = 0 ;
10717 PyObject * obj2 = 0 ;
10718 char *kwnames[] = {
10719 (char *) "self",(char *) "self",(char *) "_class", NULL
10720 };
10721
10722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10724 if (SWIG_arg_fail(1)) SWIG_fail;
10725 arg2 = obj1;
10726 arg3 = obj2;
10727 {
10728 PyThreadState* __tstate = wxPyBeginAllowThreads();
10729 (arg1)->_setCallbackInfo(arg2,arg3);
10730
10731 wxPyEndAllowThreads(__tstate);
10732 if (PyErr_Occurred()) SWIG_fail;
10733 }
10734 Py_INCREF(Py_None); resultobj = Py_None;
10735 return resultobj;
10736 fail:
10737 return NULL;
10738 }
10739
10740
10741 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10742 PyObject *resultobj;
10743 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10744 int arg2 ;
10745 int arg3 ;
10746 PyObject * obj0 = 0 ;
10747 PyObject * obj1 = 0 ;
10748 PyObject * obj2 = 0 ;
10749 char *kwnames[] = {
10750 (char *) "self",(char *) "pid",(char *) "status", NULL
10751 };
10752
10753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10755 if (SWIG_arg_fail(1)) SWIG_fail;
10756 {
10757 arg2 = (int)(SWIG_As_int(obj1));
10758 if (SWIG_arg_fail(2)) SWIG_fail;
10759 }
10760 {
10761 arg3 = (int)(SWIG_As_int(obj2));
10762 if (SWIG_arg_fail(3)) SWIG_fail;
10763 }
10764 {
10765 PyThreadState* __tstate = wxPyBeginAllowThreads();
10766 (arg1)->base_OnTerminate(arg2,arg3);
10767
10768 wxPyEndAllowThreads(__tstate);
10769 if (PyErr_Occurred()) SWIG_fail;
10770 }
10771 Py_INCREF(Py_None); resultobj = Py_None;
10772 return resultobj;
10773 fail:
10774 return NULL;
10775 }
10776
10777
10778 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10779 PyObject *resultobj;
10780 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10781 PyObject * obj0 = 0 ;
10782 char *kwnames[] = {
10783 (char *) "self", NULL
10784 };
10785
10786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10788 if (SWIG_arg_fail(1)) SWIG_fail;
10789 {
10790 PyThreadState* __tstate = wxPyBeginAllowThreads();
10791 (arg1)->Redirect();
10792
10793 wxPyEndAllowThreads(__tstate);
10794 if (PyErr_Occurred()) SWIG_fail;
10795 }
10796 Py_INCREF(Py_None); resultobj = Py_None;
10797 return resultobj;
10798 fail:
10799 return NULL;
10800 }
10801
10802
10803 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10804 PyObject *resultobj;
10805 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10806 bool result;
10807 PyObject * obj0 = 0 ;
10808 char *kwnames[] = {
10809 (char *) "self", NULL
10810 };
10811
10812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10814 if (SWIG_arg_fail(1)) SWIG_fail;
10815 {
10816 PyThreadState* __tstate = wxPyBeginAllowThreads();
10817 result = (bool)(arg1)->IsRedirected();
10818
10819 wxPyEndAllowThreads(__tstate);
10820 if (PyErr_Occurred()) SWIG_fail;
10821 }
10822 {
10823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10824 }
10825 return resultobj;
10826 fail:
10827 return NULL;
10828 }
10829
10830
10831 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10832 PyObject *resultobj;
10833 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10834 PyObject * obj0 = 0 ;
10835 char *kwnames[] = {
10836 (char *) "self", NULL
10837 };
10838
10839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10841 if (SWIG_arg_fail(1)) SWIG_fail;
10842 {
10843 PyThreadState* __tstate = wxPyBeginAllowThreads();
10844 (arg1)->Detach();
10845
10846 wxPyEndAllowThreads(__tstate);
10847 if (PyErr_Occurred()) SWIG_fail;
10848 }
10849 Py_INCREF(Py_None); resultobj = Py_None;
10850 return resultobj;
10851 fail:
10852 return NULL;
10853 }
10854
10855
10856 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10857 PyObject *resultobj;
10858 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10859 wxInputStream *result;
10860 PyObject * obj0 = 0 ;
10861 char *kwnames[] = {
10862 (char *) "self", NULL
10863 };
10864
10865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10867 if (SWIG_arg_fail(1)) SWIG_fail;
10868 {
10869 PyThreadState* __tstate = wxPyBeginAllowThreads();
10870 result = (wxInputStream *)(arg1)->GetInputStream();
10871
10872 wxPyEndAllowThreads(__tstate);
10873 if (PyErr_Occurred()) SWIG_fail;
10874 }
10875 {
10876 wxPyInputStream * _ptr = NULL;
10877
10878 if (result) {
10879 _ptr = new wxPyInputStream(result);
10880 }
10881 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10882 }
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
10890 PyObject *resultobj;
10891 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10892 wxInputStream *result;
10893 PyObject * obj0 = 0 ;
10894 char *kwnames[] = {
10895 (char *) "self", NULL
10896 };
10897
10898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
10899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10900 if (SWIG_arg_fail(1)) SWIG_fail;
10901 {
10902 PyThreadState* __tstate = wxPyBeginAllowThreads();
10903 result = (wxInputStream *)(arg1)->GetErrorStream();
10904
10905 wxPyEndAllowThreads(__tstate);
10906 if (PyErr_Occurred()) SWIG_fail;
10907 }
10908 {
10909 wxPyInputStream * _ptr = NULL;
10910
10911 if (result) {
10912 _ptr = new wxPyInputStream(result);
10913 }
10914 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10915 }
10916 return resultobj;
10917 fail:
10918 return NULL;
10919 }
10920
10921
10922 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10923 PyObject *resultobj;
10924 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10925 wxOutputStream *result;
10926 PyObject * obj0 = 0 ;
10927 char *kwnames[] = {
10928 (char *) "self", NULL
10929 };
10930
10931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
10932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10933 if (SWIG_arg_fail(1)) SWIG_fail;
10934 {
10935 PyThreadState* __tstate = wxPyBeginAllowThreads();
10936 result = (wxOutputStream *)(arg1)->GetOutputStream();
10937
10938 wxPyEndAllowThreads(__tstate);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
10942 return resultobj;
10943 fail:
10944 return NULL;
10945 }
10946
10947
10948 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj;
10950 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10951 PyObject * obj0 = 0 ;
10952 char *kwnames[] = {
10953 (char *) "self", NULL
10954 };
10955
10956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
10957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10958 if (SWIG_arg_fail(1)) SWIG_fail;
10959 {
10960 PyThreadState* __tstate = wxPyBeginAllowThreads();
10961 (arg1)->CloseOutput();
10962
10963 wxPyEndAllowThreads(__tstate);
10964 if (PyErr_Occurred()) SWIG_fail;
10965 }
10966 Py_INCREF(Py_None); resultobj = Py_None;
10967 return resultobj;
10968 fail:
10969 return NULL;
10970 }
10971
10972
10973 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
10974 PyObject *resultobj;
10975 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10976 bool result;
10977 PyObject * obj0 = 0 ;
10978 char *kwnames[] = {
10979 (char *) "self", NULL
10980 };
10981
10982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
10983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10984 if (SWIG_arg_fail(1)) SWIG_fail;
10985 {
10986 PyThreadState* __tstate = wxPyBeginAllowThreads();
10987 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
10988
10989 wxPyEndAllowThreads(__tstate);
10990 if (PyErr_Occurred()) SWIG_fail;
10991 }
10992 {
10993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10994 }
10995 return resultobj;
10996 fail:
10997 return NULL;
10998 }
10999
11000
11001 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11002 PyObject *resultobj;
11003 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11004 bool result;
11005 PyObject * obj0 = 0 ;
11006 char *kwnames[] = {
11007 (char *) "self", NULL
11008 };
11009
11010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11012 if (SWIG_arg_fail(1)) SWIG_fail;
11013 {
11014 PyThreadState* __tstate = wxPyBeginAllowThreads();
11015 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11016
11017 wxPyEndAllowThreads(__tstate);
11018 if (PyErr_Occurred()) SWIG_fail;
11019 }
11020 {
11021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11022 }
11023 return resultobj;
11024 fail:
11025 return NULL;
11026 }
11027
11028
11029 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11030 PyObject *resultobj;
11031 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11032 bool result;
11033 PyObject * obj0 = 0 ;
11034 char *kwnames[] = {
11035 (char *) "self", NULL
11036 };
11037
11038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11040 if (SWIG_arg_fail(1)) SWIG_fail;
11041 {
11042 PyThreadState* __tstate = wxPyBeginAllowThreads();
11043 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11044
11045 wxPyEndAllowThreads(__tstate);
11046 if (PyErr_Occurred()) SWIG_fail;
11047 }
11048 {
11049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11050 }
11051 return resultobj;
11052 fail:
11053 return NULL;
11054 }
11055
11056
11057 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11058 PyObject *obj;
11059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11060 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11061 Py_INCREF(obj);
11062 return Py_BuildValue((char *)"");
11063 }
11064 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11065 PyObject *resultobj;
11066 int arg1 = (int) 0 ;
11067 int arg2 = (int) 0 ;
11068 int arg3 = (int) 0 ;
11069 wxProcessEvent *result;
11070 PyObject * obj0 = 0 ;
11071 PyObject * obj1 = 0 ;
11072 PyObject * obj2 = 0 ;
11073 char *kwnames[] = {
11074 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11075 };
11076
11077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11078 if (obj0) {
11079 {
11080 arg1 = (int)(SWIG_As_int(obj0));
11081 if (SWIG_arg_fail(1)) SWIG_fail;
11082 }
11083 }
11084 if (obj1) {
11085 {
11086 arg2 = (int)(SWIG_As_int(obj1));
11087 if (SWIG_arg_fail(2)) SWIG_fail;
11088 }
11089 }
11090 if (obj2) {
11091 {
11092 arg3 = (int)(SWIG_As_int(obj2));
11093 if (SWIG_arg_fail(3)) SWIG_fail;
11094 }
11095 }
11096 {
11097 PyThreadState* __tstate = wxPyBeginAllowThreads();
11098 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11099
11100 wxPyEndAllowThreads(__tstate);
11101 if (PyErr_Occurred()) SWIG_fail;
11102 }
11103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11104 return resultobj;
11105 fail:
11106 return NULL;
11107 }
11108
11109
11110 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11111 PyObject *resultobj;
11112 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11113 int result;
11114 PyObject * obj0 = 0 ;
11115 char *kwnames[] = {
11116 (char *) "self", NULL
11117 };
11118
11119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11121 if (SWIG_arg_fail(1)) SWIG_fail;
11122 {
11123 PyThreadState* __tstate = wxPyBeginAllowThreads();
11124 result = (int)(arg1)->GetPid();
11125
11126 wxPyEndAllowThreads(__tstate);
11127 if (PyErr_Occurred()) SWIG_fail;
11128 }
11129 {
11130 resultobj = SWIG_From_int((int)(result));
11131 }
11132 return resultobj;
11133 fail:
11134 return NULL;
11135 }
11136
11137
11138 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11139 PyObject *resultobj;
11140 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11141 int result;
11142 PyObject * obj0 = 0 ;
11143 char *kwnames[] = {
11144 (char *) "self", NULL
11145 };
11146
11147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11149 if (SWIG_arg_fail(1)) SWIG_fail;
11150 {
11151 PyThreadState* __tstate = wxPyBeginAllowThreads();
11152 result = (int)(arg1)->GetExitCode();
11153
11154 wxPyEndAllowThreads(__tstate);
11155 if (PyErr_Occurred()) SWIG_fail;
11156 }
11157 {
11158 resultobj = SWIG_From_int((int)(result));
11159 }
11160 return resultobj;
11161 fail:
11162 return NULL;
11163 }
11164
11165
11166 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11167 PyObject *resultobj;
11168 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11169 int arg2 ;
11170 PyObject * obj0 = 0 ;
11171 PyObject * obj1 = 0 ;
11172 char *kwnames[] = {
11173 (char *) "self",(char *) "m_pid", NULL
11174 };
11175
11176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11178 if (SWIG_arg_fail(1)) SWIG_fail;
11179 {
11180 arg2 = (int)(SWIG_As_int(obj1));
11181 if (SWIG_arg_fail(2)) SWIG_fail;
11182 }
11183 if (arg1) (arg1)->m_pid = arg2;
11184
11185 Py_INCREF(Py_None); resultobj = Py_None;
11186 return resultobj;
11187 fail:
11188 return NULL;
11189 }
11190
11191
11192 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11193 PyObject *resultobj;
11194 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11195 int result;
11196 PyObject * obj0 = 0 ;
11197 char *kwnames[] = {
11198 (char *) "self", NULL
11199 };
11200
11201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11203 if (SWIG_arg_fail(1)) SWIG_fail;
11204 result = (int) ((arg1)->m_pid);
11205
11206 {
11207 resultobj = SWIG_From_int((int)(result));
11208 }
11209 return resultobj;
11210 fail:
11211 return NULL;
11212 }
11213
11214
11215 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11216 PyObject *resultobj;
11217 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11218 int arg2 ;
11219 PyObject * obj0 = 0 ;
11220 PyObject * obj1 = 0 ;
11221 char *kwnames[] = {
11222 (char *) "self",(char *) "m_exitcode", NULL
11223 };
11224
11225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11227 if (SWIG_arg_fail(1)) SWIG_fail;
11228 {
11229 arg2 = (int)(SWIG_As_int(obj1));
11230 if (SWIG_arg_fail(2)) SWIG_fail;
11231 }
11232 if (arg1) (arg1)->m_exitcode = arg2;
11233
11234 Py_INCREF(Py_None); resultobj = Py_None;
11235 return resultobj;
11236 fail:
11237 return NULL;
11238 }
11239
11240
11241 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11242 PyObject *resultobj;
11243 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11244 int result;
11245 PyObject * obj0 = 0 ;
11246 char *kwnames[] = {
11247 (char *) "self", NULL
11248 };
11249
11250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11252 if (SWIG_arg_fail(1)) SWIG_fail;
11253 result = (int) ((arg1)->m_exitcode);
11254
11255 {
11256 resultobj = SWIG_From_int((int)(result));
11257 }
11258 return resultobj;
11259 fail:
11260 return NULL;
11261 }
11262
11263
11264 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11265 PyObject *obj;
11266 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11267 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11268 Py_INCREF(obj);
11269 return Py_BuildValue((char *)"");
11270 }
11271 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11272 PyObject *resultobj;
11273 wxString *arg1 = 0 ;
11274 int arg2 = (int) wxEXEC_ASYNC ;
11275 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11276 long result;
11277 bool temp1 = false ;
11278 PyObject * obj0 = 0 ;
11279 PyObject * obj1 = 0 ;
11280 PyObject * obj2 = 0 ;
11281 char *kwnames[] = {
11282 (char *) "command",(char *) "flags",(char *) "process", NULL
11283 };
11284
11285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11286 {
11287 arg1 = wxString_in_helper(obj0);
11288 if (arg1 == NULL) SWIG_fail;
11289 temp1 = true;
11290 }
11291 if (obj1) {
11292 {
11293 arg2 = (int)(SWIG_As_int(obj1));
11294 if (SWIG_arg_fail(2)) SWIG_fail;
11295 }
11296 }
11297 if (obj2) {
11298 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11299 if (SWIG_arg_fail(3)) SWIG_fail;
11300 }
11301 {
11302 if (!wxPyCheckForApp()) SWIG_fail;
11303 PyThreadState* __tstate = wxPyBeginAllowThreads();
11304 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11305
11306 wxPyEndAllowThreads(__tstate);
11307 if (PyErr_Occurred()) SWIG_fail;
11308 }
11309 {
11310 resultobj = SWIG_From_long((long)(result));
11311 }
11312 {
11313 if (temp1)
11314 delete arg1;
11315 }
11316 return resultobj;
11317 fail:
11318 {
11319 if (temp1)
11320 delete arg1;
11321 }
11322 return NULL;
11323 }
11324
11325
11326 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11327 PyObject *resultobj;
11328 long arg1 ;
11329 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11330 wxKillError *arg3 = (wxKillError *) 0 ;
11331 int arg4 = (int) wxKILL_NOCHILDREN ;
11332 int result;
11333 wxKillError temp3 ;
11334 PyObject * obj0 = 0 ;
11335 PyObject * obj1 = 0 ;
11336 PyObject * obj2 = 0 ;
11337 char *kwnames[] = {
11338 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11339 };
11340
11341 {
11342 arg3 = &temp3;
11343 }
11344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11345 {
11346 arg1 = (long)(SWIG_As_long(obj0));
11347 if (SWIG_arg_fail(1)) SWIG_fail;
11348 }
11349 if (obj1) {
11350 {
11351 arg2 = (wxSignal)(SWIG_As_int(obj1));
11352 if (SWIG_arg_fail(2)) SWIG_fail;
11353 }
11354 }
11355 if (obj2) {
11356 {
11357 arg4 = (int)(SWIG_As_int(obj2));
11358 if (SWIG_arg_fail(4)) SWIG_fail;
11359 }
11360 }
11361 {
11362 PyThreadState* __tstate = wxPyBeginAllowThreads();
11363 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11364
11365 wxPyEndAllowThreads(__tstate);
11366 if (PyErr_Occurred()) SWIG_fail;
11367 }
11368 {
11369 resultobj = SWIG_From_int((int)(result));
11370 }
11371 {
11372 PyObject* o;
11373 o = PyInt_FromLong((long) (*arg3));
11374 resultobj = t_output_helper(resultobj, o);
11375 }
11376 return resultobj;
11377 fail:
11378 return NULL;
11379 }
11380
11381
11382 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11383 PyObject *resultobj;
11384 int arg1 = (int) wxJOYSTICK1 ;
11385 wxJoystick *result;
11386 PyObject * obj0 = 0 ;
11387 char *kwnames[] = {
11388 (char *) "joystick", NULL
11389 };
11390
11391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11392 if (obj0) {
11393 {
11394 arg1 = (int)(SWIG_As_int(obj0));
11395 if (SWIG_arg_fail(1)) SWIG_fail;
11396 }
11397 }
11398 {
11399 if (!wxPyCheckForApp()) SWIG_fail;
11400 PyThreadState* __tstate = wxPyBeginAllowThreads();
11401 result = (wxJoystick *)new wxJoystick(arg1);
11402
11403 wxPyEndAllowThreads(__tstate);
11404 if (PyErr_Occurred()) SWIG_fail;
11405 }
11406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11407 return resultobj;
11408 fail:
11409 return NULL;
11410 }
11411
11412
11413 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11414 PyObject *resultobj;
11415 wxJoystick *arg1 = (wxJoystick *) 0 ;
11416 PyObject * obj0 = 0 ;
11417 char *kwnames[] = {
11418 (char *) "self", NULL
11419 };
11420
11421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11423 if (SWIG_arg_fail(1)) SWIG_fail;
11424 {
11425 PyThreadState* __tstate = wxPyBeginAllowThreads();
11426 delete arg1;
11427
11428 wxPyEndAllowThreads(__tstate);
11429 if (PyErr_Occurred()) SWIG_fail;
11430 }
11431 Py_INCREF(Py_None); resultobj = Py_None;
11432 return resultobj;
11433 fail:
11434 return NULL;
11435 }
11436
11437
11438 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11439 PyObject *resultobj;
11440 wxJoystick *arg1 = (wxJoystick *) 0 ;
11441 wxPoint result;
11442 PyObject * obj0 = 0 ;
11443 char *kwnames[] = {
11444 (char *) "self", NULL
11445 };
11446
11447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11449 if (SWIG_arg_fail(1)) SWIG_fail;
11450 {
11451 PyThreadState* __tstate = wxPyBeginAllowThreads();
11452 result = (arg1)->GetPosition();
11453
11454 wxPyEndAllowThreads(__tstate);
11455 if (PyErr_Occurred()) SWIG_fail;
11456 }
11457 {
11458 wxPoint * resultptr;
11459 resultptr = new wxPoint((wxPoint &)(result));
11460 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11461 }
11462 return resultobj;
11463 fail:
11464 return NULL;
11465 }
11466
11467
11468 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11469 PyObject *resultobj;
11470 wxJoystick *arg1 = (wxJoystick *) 0 ;
11471 int result;
11472 PyObject * obj0 = 0 ;
11473 char *kwnames[] = {
11474 (char *) "self", NULL
11475 };
11476
11477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11479 if (SWIG_arg_fail(1)) SWIG_fail;
11480 {
11481 PyThreadState* __tstate = wxPyBeginAllowThreads();
11482 result = (int)(arg1)->GetZPosition();
11483
11484 wxPyEndAllowThreads(__tstate);
11485 if (PyErr_Occurred()) SWIG_fail;
11486 }
11487 {
11488 resultobj = SWIG_From_int((int)(result));
11489 }
11490 return resultobj;
11491 fail:
11492 return NULL;
11493 }
11494
11495
11496 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11497 PyObject *resultobj;
11498 wxJoystick *arg1 = (wxJoystick *) 0 ;
11499 int result;
11500 PyObject * obj0 = 0 ;
11501 char *kwnames[] = {
11502 (char *) "self", NULL
11503 };
11504
11505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11507 if (SWIG_arg_fail(1)) SWIG_fail;
11508 {
11509 PyThreadState* __tstate = wxPyBeginAllowThreads();
11510 result = (int)(arg1)->GetButtonState();
11511
11512 wxPyEndAllowThreads(__tstate);
11513 if (PyErr_Occurred()) SWIG_fail;
11514 }
11515 {
11516 resultobj = SWIG_From_int((int)(result));
11517 }
11518 return resultobj;
11519 fail:
11520 return NULL;
11521 }
11522
11523
11524 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11525 PyObject *resultobj;
11526 wxJoystick *arg1 = (wxJoystick *) 0 ;
11527 int result;
11528 PyObject * obj0 = 0 ;
11529 char *kwnames[] = {
11530 (char *) "self", NULL
11531 };
11532
11533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11535 if (SWIG_arg_fail(1)) SWIG_fail;
11536 {
11537 PyThreadState* __tstate = wxPyBeginAllowThreads();
11538 result = (int)(arg1)->GetPOVPosition();
11539
11540 wxPyEndAllowThreads(__tstate);
11541 if (PyErr_Occurred()) SWIG_fail;
11542 }
11543 {
11544 resultobj = SWIG_From_int((int)(result));
11545 }
11546 return resultobj;
11547 fail:
11548 return NULL;
11549 }
11550
11551
11552 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11553 PyObject *resultobj;
11554 wxJoystick *arg1 = (wxJoystick *) 0 ;
11555 int result;
11556 PyObject * obj0 = 0 ;
11557 char *kwnames[] = {
11558 (char *) "self", NULL
11559 };
11560
11561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11563 if (SWIG_arg_fail(1)) SWIG_fail;
11564 {
11565 PyThreadState* __tstate = wxPyBeginAllowThreads();
11566 result = (int)(arg1)->GetPOVCTSPosition();
11567
11568 wxPyEndAllowThreads(__tstate);
11569 if (PyErr_Occurred()) SWIG_fail;
11570 }
11571 {
11572 resultobj = SWIG_From_int((int)(result));
11573 }
11574 return resultobj;
11575 fail:
11576 return NULL;
11577 }
11578
11579
11580 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11581 PyObject *resultobj;
11582 wxJoystick *arg1 = (wxJoystick *) 0 ;
11583 int result;
11584 PyObject * obj0 = 0 ;
11585 char *kwnames[] = {
11586 (char *) "self", NULL
11587 };
11588
11589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11591 if (SWIG_arg_fail(1)) SWIG_fail;
11592 {
11593 PyThreadState* __tstate = wxPyBeginAllowThreads();
11594 result = (int)(arg1)->GetRudderPosition();
11595
11596 wxPyEndAllowThreads(__tstate);
11597 if (PyErr_Occurred()) SWIG_fail;
11598 }
11599 {
11600 resultobj = SWIG_From_int((int)(result));
11601 }
11602 return resultobj;
11603 fail:
11604 return NULL;
11605 }
11606
11607
11608 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11609 PyObject *resultobj;
11610 wxJoystick *arg1 = (wxJoystick *) 0 ;
11611 int result;
11612 PyObject * obj0 = 0 ;
11613 char *kwnames[] = {
11614 (char *) "self", NULL
11615 };
11616
11617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11619 if (SWIG_arg_fail(1)) SWIG_fail;
11620 {
11621 PyThreadState* __tstate = wxPyBeginAllowThreads();
11622 result = (int)(arg1)->GetUPosition();
11623
11624 wxPyEndAllowThreads(__tstate);
11625 if (PyErr_Occurred()) SWIG_fail;
11626 }
11627 {
11628 resultobj = SWIG_From_int((int)(result));
11629 }
11630 return resultobj;
11631 fail:
11632 return NULL;
11633 }
11634
11635
11636 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11637 PyObject *resultobj;
11638 wxJoystick *arg1 = (wxJoystick *) 0 ;
11639 int result;
11640 PyObject * obj0 = 0 ;
11641 char *kwnames[] = {
11642 (char *) "self", NULL
11643 };
11644
11645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11647 if (SWIG_arg_fail(1)) SWIG_fail;
11648 {
11649 PyThreadState* __tstate = wxPyBeginAllowThreads();
11650 result = (int)(arg1)->GetVPosition();
11651
11652 wxPyEndAllowThreads(__tstate);
11653 if (PyErr_Occurred()) SWIG_fail;
11654 }
11655 {
11656 resultobj = SWIG_From_int((int)(result));
11657 }
11658 return resultobj;
11659 fail:
11660 return NULL;
11661 }
11662
11663
11664 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11665 PyObject *resultobj;
11666 wxJoystick *arg1 = (wxJoystick *) 0 ;
11667 int result;
11668 PyObject * obj0 = 0 ;
11669 char *kwnames[] = {
11670 (char *) "self", NULL
11671 };
11672
11673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11675 if (SWIG_arg_fail(1)) SWIG_fail;
11676 {
11677 PyThreadState* __tstate = wxPyBeginAllowThreads();
11678 result = (int)(arg1)->GetMovementThreshold();
11679
11680 wxPyEndAllowThreads(__tstate);
11681 if (PyErr_Occurred()) SWIG_fail;
11682 }
11683 {
11684 resultobj = SWIG_From_int((int)(result));
11685 }
11686 return resultobj;
11687 fail:
11688 return NULL;
11689 }
11690
11691
11692 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11693 PyObject *resultobj;
11694 wxJoystick *arg1 = (wxJoystick *) 0 ;
11695 int arg2 ;
11696 PyObject * obj0 = 0 ;
11697 PyObject * obj1 = 0 ;
11698 char *kwnames[] = {
11699 (char *) "self",(char *) "threshold", NULL
11700 };
11701
11702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11704 if (SWIG_arg_fail(1)) SWIG_fail;
11705 {
11706 arg2 = (int)(SWIG_As_int(obj1));
11707 if (SWIG_arg_fail(2)) SWIG_fail;
11708 }
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 (arg1)->SetMovementThreshold(arg2);
11712
11713 wxPyEndAllowThreads(__tstate);
11714 if (PyErr_Occurred()) SWIG_fail;
11715 }
11716 Py_INCREF(Py_None); resultobj = Py_None;
11717 return resultobj;
11718 fail:
11719 return NULL;
11720 }
11721
11722
11723 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11724 PyObject *resultobj;
11725 wxJoystick *arg1 = (wxJoystick *) 0 ;
11726 bool result;
11727 PyObject * obj0 = 0 ;
11728 char *kwnames[] = {
11729 (char *) "self", NULL
11730 };
11731
11732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11734 if (SWIG_arg_fail(1)) SWIG_fail;
11735 {
11736 PyThreadState* __tstate = wxPyBeginAllowThreads();
11737 result = (bool)(arg1)->IsOk();
11738
11739 wxPyEndAllowThreads(__tstate);
11740 if (PyErr_Occurred()) SWIG_fail;
11741 }
11742 {
11743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11744 }
11745 return resultobj;
11746 fail:
11747 return NULL;
11748 }
11749
11750
11751 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11752 PyObject *resultobj;
11753 wxJoystick *arg1 = (wxJoystick *) 0 ;
11754 int result;
11755 PyObject * obj0 = 0 ;
11756 char *kwnames[] = {
11757 (char *) "self", NULL
11758 };
11759
11760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11762 if (SWIG_arg_fail(1)) SWIG_fail;
11763 {
11764 PyThreadState* __tstate = wxPyBeginAllowThreads();
11765 result = (int)(arg1)->GetNumberJoysticks();
11766
11767 wxPyEndAllowThreads(__tstate);
11768 if (PyErr_Occurred()) SWIG_fail;
11769 }
11770 {
11771 resultobj = SWIG_From_int((int)(result));
11772 }
11773 return resultobj;
11774 fail:
11775 return NULL;
11776 }
11777
11778
11779 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11780 PyObject *resultobj;
11781 wxJoystick *arg1 = (wxJoystick *) 0 ;
11782 int result;
11783 PyObject * obj0 = 0 ;
11784 char *kwnames[] = {
11785 (char *) "self", NULL
11786 };
11787
11788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11790 if (SWIG_arg_fail(1)) SWIG_fail;
11791 {
11792 PyThreadState* __tstate = wxPyBeginAllowThreads();
11793 result = (int)(arg1)->GetManufacturerId();
11794
11795 wxPyEndAllowThreads(__tstate);
11796 if (PyErr_Occurred()) SWIG_fail;
11797 }
11798 {
11799 resultobj = SWIG_From_int((int)(result));
11800 }
11801 return resultobj;
11802 fail:
11803 return NULL;
11804 }
11805
11806
11807 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11808 PyObject *resultobj;
11809 wxJoystick *arg1 = (wxJoystick *) 0 ;
11810 int result;
11811 PyObject * obj0 = 0 ;
11812 char *kwnames[] = {
11813 (char *) "self", NULL
11814 };
11815
11816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11818 if (SWIG_arg_fail(1)) SWIG_fail;
11819 {
11820 PyThreadState* __tstate = wxPyBeginAllowThreads();
11821 result = (int)(arg1)->GetProductId();
11822
11823 wxPyEndAllowThreads(__tstate);
11824 if (PyErr_Occurred()) SWIG_fail;
11825 }
11826 {
11827 resultobj = SWIG_From_int((int)(result));
11828 }
11829 return resultobj;
11830 fail:
11831 return NULL;
11832 }
11833
11834
11835 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11836 PyObject *resultobj;
11837 wxJoystick *arg1 = (wxJoystick *) 0 ;
11838 wxString result;
11839 PyObject * obj0 = 0 ;
11840 char *kwnames[] = {
11841 (char *) "self", NULL
11842 };
11843
11844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11846 if (SWIG_arg_fail(1)) SWIG_fail;
11847 {
11848 PyThreadState* __tstate = wxPyBeginAllowThreads();
11849 result = (arg1)->GetProductName();
11850
11851 wxPyEndAllowThreads(__tstate);
11852 if (PyErr_Occurred()) SWIG_fail;
11853 }
11854 {
11855 #if wxUSE_UNICODE
11856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11857 #else
11858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11859 #endif
11860 }
11861 return resultobj;
11862 fail:
11863 return NULL;
11864 }
11865
11866
11867 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11868 PyObject *resultobj;
11869 wxJoystick *arg1 = (wxJoystick *) 0 ;
11870 int result;
11871 PyObject * obj0 = 0 ;
11872 char *kwnames[] = {
11873 (char *) "self", NULL
11874 };
11875
11876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
11877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11878 if (SWIG_arg_fail(1)) SWIG_fail;
11879 {
11880 PyThreadState* __tstate = wxPyBeginAllowThreads();
11881 result = (int)(arg1)->GetXMin();
11882
11883 wxPyEndAllowThreads(__tstate);
11884 if (PyErr_Occurred()) SWIG_fail;
11885 }
11886 {
11887 resultobj = SWIG_From_int((int)(result));
11888 }
11889 return resultobj;
11890 fail:
11891 return NULL;
11892 }
11893
11894
11895 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
11896 PyObject *resultobj;
11897 wxJoystick *arg1 = (wxJoystick *) 0 ;
11898 int result;
11899 PyObject * obj0 = 0 ;
11900 char *kwnames[] = {
11901 (char *) "self", NULL
11902 };
11903
11904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
11905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11906 if (SWIG_arg_fail(1)) SWIG_fail;
11907 {
11908 PyThreadState* __tstate = wxPyBeginAllowThreads();
11909 result = (int)(arg1)->GetYMin();
11910
11911 wxPyEndAllowThreads(__tstate);
11912 if (PyErr_Occurred()) SWIG_fail;
11913 }
11914 {
11915 resultobj = SWIG_From_int((int)(result));
11916 }
11917 return resultobj;
11918 fail:
11919 return NULL;
11920 }
11921
11922
11923 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
11924 PyObject *resultobj;
11925 wxJoystick *arg1 = (wxJoystick *) 0 ;
11926 int result;
11927 PyObject * obj0 = 0 ;
11928 char *kwnames[] = {
11929 (char *) "self", NULL
11930 };
11931
11932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
11933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11934 if (SWIG_arg_fail(1)) SWIG_fail;
11935 {
11936 PyThreadState* __tstate = wxPyBeginAllowThreads();
11937 result = (int)(arg1)->GetZMin();
11938
11939 wxPyEndAllowThreads(__tstate);
11940 if (PyErr_Occurred()) SWIG_fail;
11941 }
11942 {
11943 resultobj = SWIG_From_int((int)(result));
11944 }
11945 return resultobj;
11946 fail:
11947 return NULL;
11948 }
11949
11950
11951 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
11952 PyObject *resultobj;
11953 wxJoystick *arg1 = (wxJoystick *) 0 ;
11954 int result;
11955 PyObject * obj0 = 0 ;
11956 char *kwnames[] = {
11957 (char *) "self", NULL
11958 };
11959
11960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
11965 result = (int)(arg1)->GetXMax();
11966
11967 wxPyEndAllowThreads(__tstate);
11968 if (PyErr_Occurred()) SWIG_fail;
11969 }
11970 {
11971 resultobj = SWIG_From_int((int)(result));
11972 }
11973 return resultobj;
11974 fail:
11975 return NULL;
11976 }
11977
11978
11979 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
11980 PyObject *resultobj;
11981 wxJoystick *arg1 = (wxJoystick *) 0 ;
11982 int result;
11983 PyObject * obj0 = 0 ;
11984 char *kwnames[] = {
11985 (char *) "self", NULL
11986 };
11987
11988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
11989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11990 if (SWIG_arg_fail(1)) SWIG_fail;
11991 {
11992 PyThreadState* __tstate = wxPyBeginAllowThreads();
11993 result = (int)(arg1)->GetYMax();
11994
11995 wxPyEndAllowThreads(__tstate);
11996 if (PyErr_Occurred()) SWIG_fail;
11997 }
11998 {
11999 resultobj = SWIG_From_int((int)(result));
12000 }
12001 return resultobj;
12002 fail:
12003 return NULL;
12004 }
12005
12006
12007 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12008 PyObject *resultobj;
12009 wxJoystick *arg1 = (wxJoystick *) 0 ;
12010 int result;
12011 PyObject * obj0 = 0 ;
12012 char *kwnames[] = {
12013 (char *) "self", NULL
12014 };
12015
12016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12018 if (SWIG_arg_fail(1)) SWIG_fail;
12019 {
12020 PyThreadState* __tstate = wxPyBeginAllowThreads();
12021 result = (int)(arg1)->GetZMax();
12022
12023 wxPyEndAllowThreads(__tstate);
12024 if (PyErr_Occurred()) SWIG_fail;
12025 }
12026 {
12027 resultobj = SWIG_From_int((int)(result));
12028 }
12029 return resultobj;
12030 fail:
12031 return NULL;
12032 }
12033
12034
12035 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12036 PyObject *resultobj;
12037 wxJoystick *arg1 = (wxJoystick *) 0 ;
12038 int result;
12039 PyObject * obj0 = 0 ;
12040 char *kwnames[] = {
12041 (char *) "self", NULL
12042 };
12043
12044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12046 if (SWIG_arg_fail(1)) SWIG_fail;
12047 {
12048 PyThreadState* __tstate = wxPyBeginAllowThreads();
12049 result = (int)(arg1)->GetNumberButtons();
12050
12051 wxPyEndAllowThreads(__tstate);
12052 if (PyErr_Occurred()) SWIG_fail;
12053 }
12054 {
12055 resultobj = SWIG_From_int((int)(result));
12056 }
12057 return resultobj;
12058 fail:
12059 return NULL;
12060 }
12061
12062
12063 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12064 PyObject *resultobj;
12065 wxJoystick *arg1 = (wxJoystick *) 0 ;
12066 int result;
12067 PyObject * obj0 = 0 ;
12068 char *kwnames[] = {
12069 (char *) "self", NULL
12070 };
12071
12072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12074 if (SWIG_arg_fail(1)) SWIG_fail;
12075 {
12076 PyThreadState* __tstate = wxPyBeginAllowThreads();
12077 result = (int)(arg1)->GetNumberAxes();
12078
12079 wxPyEndAllowThreads(__tstate);
12080 if (PyErr_Occurred()) SWIG_fail;
12081 }
12082 {
12083 resultobj = SWIG_From_int((int)(result));
12084 }
12085 return resultobj;
12086 fail:
12087 return NULL;
12088 }
12089
12090
12091 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12092 PyObject *resultobj;
12093 wxJoystick *arg1 = (wxJoystick *) 0 ;
12094 int result;
12095 PyObject * obj0 = 0 ;
12096 char *kwnames[] = {
12097 (char *) "self", NULL
12098 };
12099
12100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12102 if (SWIG_arg_fail(1)) SWIG_fail;
12103 {
12104 PyThreadState* __tstate = wxPyBeginAllowThreads();
12105 result = (int)(arg1)->GetMaxButtons();
12106
12107 wxPyEndAllowThreads(__tstate);
12108 if (PyErr_Occurred()) SWIG_fail;
12109 }
12110 {
12111 resultobj = SWIG_From_int((int)(result));
12112 }
12113 return resultobj;
12114 fail:
12115 return NULL;
12116 }
12117
12118
12119 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12120 PyObject *resultobj;
12121 wxJoystick *arg1 = (wxJoystick *) 0 ;
12122 int result;
12123 PyObject * obj0 = 0 ;
12124 char *kwnames[] = {
12125 (char *) "self", NULL
12126 };
12127
12128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12130 if (SWIG_arg_fail(1)) SWIG_fail;
12131 {
12132 PyThreadState* __tstate = wxPyBeginAllowThreads();
12133 result = (int)(arg1)->GetMaxAxes();
12134
12135 wxPyEndAllowThreads(__tstate);
12136 if (PyErr_Occurred()) SWIG_fail;
12137 }
12138 {
12139 resultobj = SWIG_From_int((int)(result));
12140 }
12141 return resultobj;
12142 fail:
12143 return NULL;
12144 }
12145
12146
12147 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12148 PyObject *resultobj;
12149 wxJoystick *arg1 = (wxJoystick *) 0 ;
12150 int result;
12151 PyObject * obj0 = 0 ;
12152 char *kwnames[] = {
12153 (char *) "self", NULL
12154 };
12155
12156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12158 if (SWIG_arg_fail(1)) SWIG_fail;
12159 {
12160 PyThreadState* __tstate = wxPyBeginAllowThreads();
12161 result = (int)(arg1)->GetPollingMin();
12162
12163 wxPyEndAllowThreads(__tstate);
12164 if (PyErr_Occurred()) SWIG_fail;
12165 }
12166 {
12167 resultobj = SWIG_From_int((int)(result));
12168 }
12169 return resultobj;
12170 fail:
12171 return NULL;
12172 }
12173
12174
12175 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12176 PyObject *resultobj;
12177 wxJoystick *arg1 = (wxJoystick *) 0 ;
12178 int result;
12179 PyObject * obj0 = 0 ;
12180 char *kwnames[] = {
12181 (char *) "self", NULL
12182 };
12183
12184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12186 if (SWIG_arg_fail(1)) SWIG_fail;
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 result = (int)(arg1)->GetPollingMax();
12190
12191 wxPyEndAllowThreads(__tstate);
12192 if (PyErr_Occurred()) SWIG_fail;
12193 }
12194 {
12195 resultobj = SWIG_From_int((int)(result));
12196 }
12197 return resultobj;
12198 fail:
12199 return NULL;
12200 }
12201
12202
12203 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12204 PyObject *resultobj;
12205 wxJoystick *arg1 = (wxJoystick *) 0 ;
12206 int result;
12207 PyObject * obj0 = 0 ;
12208 char *kwnames[] = {
12209 (char *) "self", NULL
12210 };
12211
12212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12214 if (SWIG_arg_fail(1)) SWIG_fail;
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 result = (int)(arg1)->GetRudderMin();
12218
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 {
12223 resultobj = SWIG_From_int((int)(result));
12224 }
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12232 PyObject *resultobj;
12233 wxJoystick *arg1 = (wxJoystick *) 0 ;
12234 int result;
12235 PyObject * obj0 = 0 ;
12236 char *kwnames[] = {
12237 (char *) "self", NULL
12238 };
12239
12240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12242 if (SWIG_arg_fail(1)) SWIG_fail;
12243 {
12244 PyThreadState* __tstate = wxPyBeginAllowThreads();
12245 result = (int)(arg1)->GetRudderMax();
12246
12247 wxPyEndAllowThreads(__tstate);
12248 if (PyErr_Occurred()) SWIG_fail;
12249 }
12250 {
12251 resultobj = SWIG_From_int((int)(result));
12252 }
12253 return resultobj;
12254 fail:
12255 return NULL;
12256 }
12257
12258
12259 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12260 PyObject *resultobj;
12261 wxJoystick *arg1 = (wxJoystick *) 0 ;
12262 int result;
12263 PyObject * obj0 = 0 ;
12264 char *kwnames[] = {
12265 (char *) "self", NULL
12266 };
12267
12268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12270 if (SWIG_arg_fail(1)) SWIG_fail;
12271 {
12272 PyThreadState* __tstate = wxPyBeginAllowThreads();
12273 result = (int)(arg1)->GetUMin();
12274
12275 wxPyEndAllowThreads(__tstate);
12276 if (PyErr_Occurred()) SWIG_fail;
12277 }
12278 {
12279 resultobj = SWIG_From_int((int)(result));
12280 }
12281 return resultobj;
12282 fail:
12283 return NULL;
12284 }
12285
12286
12287 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12288 PyObject *resultobj;
12289 wxJoystick *arg1 = (wxJoystick *) 0 ;
12290 int result;
12291 PyObject * obj0 = 0 ;
12292 char *kwnames[] = {
12293 (char *) "self", NULL
12294 };
12295
12296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12298 if (SWIG_arg_fail(1)) SWIG_fail;
12299 {
12300 PyThreadState* __tstate = wxPyBeginAllowThreads();
12301 result = (int)(arg1)->GetUMax();
12302
12303 wxPyEndAllowThreads(__tstate);
12304 if (PyErr_Occurred()) SWIG_fail;
12305 }
12306 {
12307 resultobj = SWIG_From_int((int)(result));
12308 }
12309 return resultobj;
12310 fail:
12311 return NULL;
12312 }
12313
12314
12315 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12316 PyObject *resultobj;
12317 wxJoystick *arg1 = (wxJoystick *) 0 ;
12318 int result;
12319 PyObject * obj0 = 0 ;
12320 char *kwnames[] = {
12321 (char *) "self", NULL
12322 };
12323
12324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12326 if (SWIG_arg_fail(1)) SWIG_fail;
12327 {
12328 PyThreadState* __tstate = wxPyBeginAllowThreads();
12329 result = (int)(arg1)->GetVMin();
12330
12331 wxPyEndAllowThreads(__tstate);
12332 if (PyErr_Occurred()) SWIG_fail;
12333 }
12334 {
12335 resultobj = SWIG_From_int((int)(result));
12336 }
12337 return resultobj;
12338 fail:
12339 return NULL;
12340 }
12341
12342
12343 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12344 PyObject *resultobj;
12345 wxJoystick *arg1 = (wxJoystick *) 0 ;
12346 int result;
12347 PyObject * obj0 = 0 ;
12348 char *kwnames[] = {
12349 (char *) "self", NULL
12350 };
12351
12352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12354 if (SWIG_arg_fail(1)) SWIG_fail;
12355 {
12356 PyThreadState* __tstate = wxPyBeginAllowThreads();
12357 result = (int)(arg1)->GetVMax();
12358
12359 wxPyEndAllowThreads(__tstate);
12360 if (PyErr_Occurred()) SWIG_fail;
12361 }
12362 {
12363 resultobj = SWIG_From_int((int)(result));
12364 }
12365 return resultobj;
12366 fail:
12367 return NULL;
12368 }
12369
12370
12371 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12372 PyObject *resultobj;
12373 wxJoystick *arg1 = (wxJoystick *) 0 ;
12374 bool result;
12375 PyObject * obj0 = 0 ;
12376 char *kwnames[] = {
12377 (char *) "self", NULL
12378 };
12379
12380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12382 if (SWIG_arg_fail(1)) SWIG_fail;
12383 {
12384 PyThreadState* __tstate = wxPyBeginAllowThreads();
12385 result = (bool)(arg1)->HasRudder();
12386
12387 wxPyEndAllowThreads(__tstate);
12388 if (PyErr_Occurred()) SWIG_fail;
12389 }
12390 {
12391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12392 }
12393 return resultobj;
12394 fail:
12395 return NULL;
12396 }
12397
12398
12399 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12400 PyObject *resultobj;
12401 wxJoystick *arg1 = (wxJoystick *) 0 ;
12402 bool result;
12403 PyObject * obj0 = 0 ;
12404 char *kwnames[] = {
12405 (char *) "self", NULL
12406 };
12407
12408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12410 if (SWIG_arg_fail(1)) SWIG_fail;
12411 {
12412 PyThreadState* __tstate = wxPyBeginAllowThreads();
12413 result = (bool)(arg1)->HasZ();
12414
12415 wxPyEndAllowThreads(__tstate);
12416 if (PyErr_Occurred()) SWIG_fail;
12417 }
12418 {
12419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12420 }
12421 return resultobj;
12422 fail:
12423 return NULL;
12424 }
12425
12426
12427 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12428 PyObject *resultobj;
12429 wxJoystick *arg1 = (wxJoystick *) 0 ;
12430 bool result;
12431 PyObject * obj0 = 0 ;
12432 char *kwnames[] = {
12433 (char *) "self", NULL
12434 };
12435
12436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12438 if (SWIG_arg_fail(1)) SWIG_fail;
12439 {
12440 PyThreadState* __tstate = wxPyBeginAllowThreads();
12441 result = (bool)(arg1)->HasU();
12442
12443 wxPyEndAllowThreads(__tstate);
12444 if (PyErr_Occurred()) SWIG_fail;
12445 }
12446 {
12447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12448 }
12449 return resultobj;
12450 fail:
12451 return NULL;
12452 }
12453
12454
12455 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12456 PyObject *resultobj;
12457 wxJoystick *arg1 = (wxJoystick *) 0 ;
12458 bool result;
12459 PyObject * obj0 = 0 ;
12460 char *kwnames[] = {
12461 (char *) "self", NULL
12462 };
12463
12464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12466 if (SWIG_arg_fail(1)) SWIG_fail;
12467 {
12468 PyThreadState* __tstate = wxPyBeginAllowThreads();
12469 result = (bool)(arg1)->HasV();
12470
12471 wxPyEndAllowThreads(__tstate);
12472 if (PyErr_Occurred()) SWIG_fail;
12473 }
12474 {
12475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12476 }
12477 return resultobj;
12478 fail:
12479 return NULL;
12480 }
12481
12482
12483 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12484 PyObject *resultobj;
12485 wxJoystick *arg1 = (wxJoystick *) 0 ;
12486 bool result;
12487 PyObject * obj0 = 0 ;
12488 char *kwnames[] = {
12489 (char *) "self", NULL
12490 };
12491
12492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12494 if (SWIG_arg_fail(1)) SWIG_fail;
12495 {
12496 PyThreadState* __tstate = wxPyBeginAllowThreads();
12497 result = (bool)(arg1)->HasPOV();
12498
12499 wxPyEndAllowThreads(__tstate);
12500 if (PyErr_Occurred()) SWIG_fail;
12501 }
12502 {
12503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12504 }
12505 return resultobj;
12506 fail:
12507 return NULL;
12508 }
12509
12510
12511 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12512 PyObject *resultobj;
12513 wxJoystick *arg1 = (wxJoystick *) 0 ;
12514 bool result;
12515 PyObject * obj0 = 0 ;
12516 char *kwnames[] = {
12517 (char *) "self", NULL
12518 };
12519
12520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12522 if (SWIG_arg_fail(1)) SWIG_fail;
12523 {
12524 PyThreadState* __tstate = wxPyBeginAllowThreads();
12525 result = (bool)(arg1)->HasPOV4Dir();
12526
12527 wxPyEndAllowThreads(__tstate);
12528 if (PyErr_Occurred()) SWIG_fail;
12529 }
12530 {
12531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12532 }
12533 return resultobj;
12534 fail:
12535 return NULL;
12536 }
12537
12538
12539 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12540 PyObject *resultobj;
12541 wxJoystick *arg1 = (wxJoystick *) 0 ;
12542 bool result;
12543 PyObject * obj0 = 0 ;
12544 char *kwnames[] = {
12545 (char *) "self", NULL
12546 };
12547
12548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12550 if (SWIG_arg_fail(1)) SWIG_fail;
12551 {
12552 PyThreadState* __tstate = wxPyBeginAllowThreads();
12553 result = (bool)(arg1)->HasPOVCTS();
12554
12555 wxPyEndAllowThreads(__tstate);
12556 if (PyErr_Occurred()) SWIG_fail;
12557 }
12558 {
12559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12560 }
12561 return resultobj;
12562 fail:
12563 return NULL;
12564 }
12565
12566
12567 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12568 PyObject *resultobj;
12569 wxJoystick *arg1 = (wxJoystick *) 0 ;
12570 wxWindow *arg2 = (wxWindow *) 0 ;
12571 int arg3 = (int) 0 ;
12572 bool result;
12573 PyObject * obj0 = 0 ;
12574 PyObject * obj1 = 0 ;
12575 PyObject * obj2 = 0 ;
12576 char *kwnames[] = {
12577 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12578 };
12579
12580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12582 if (SWIG_arg_fail(1)) SWIG_fail;
12583 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12584 if (SWIG_arg_fail(2)) SWIG_fail;
12585 if (obj2) {
12586 {
12587 arg3 = (int)(SWIG_As_int(obj2));
12588 if (SWIG_arg_fail(3)) SWIG_fail;
12589 }
12590 }
12591 {
12592 PyThreadState* __tstate = wxPyBeginAllowThreads();
12593 result = (bool)(arg1)->SetCapture(arg2,arg3);
12594
12595 wxPyEndAllowThreads(__tstate);
12596 if (PyErr_Occurred()) SWIG_fail;
12597 }
12598 {
12599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12600 }
12601 return resultobj;
12602 fail:
12603 return NULL;
12604 }
12605
12606
12607 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12608 PyObject *resultobj;
12609 wxJoystick *arg1 = (wxJoystick *) 0 ;
12610 bool result;
12611 PyObject * obj0 = 0 ;
12612 char *kwnames[] = {
12613 (char *) "self", NULL
12614 };
12615
12616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12618 if (SWIG_arg_fail(1)) SWIG_fail;
12619 {
12620 PyThreadState* __tstate = wxPyBeginAllowThreads();
12621 result = (bool)(arg1)->ReleaseCapture();
12622
12623 wxPyEndAllowThreads(__tstate);
12624 if (PyErr_Occurred()) SWIG_fail;
12625 }
12626 {
12627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12628 }
12629 return resultobj;
12630 fail:
12631 return NULL;
12632 }
12633
12634
12635 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12636 PyObject *obj;
12637 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12638 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12639 Py_INCREF(obj);
12640 return Py_BuildValue((char *)"");
12641 }
12642 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12643 PyObject *resultobj;
12644 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12645 int arg2 = (int) 0 ;
12646 int arg3 = (int) wxJOYSTICK1 ;
12647 int arg4 = (int) 0 ;
12648 wxJoystickEvent *result;
12649 PyObject * obj0 = 0 ;
12650 PyObject * obj1 = 0 ;
12651 PyObject * obj2 = 0 ;
12652 PyObject * obj3 = 0 ;
12653 char *kwnames[] = {
12654 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12655 };
12656
12657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12658 if (obj0) {
12659 {
12660 arg1 = (wxEventType)(SWIG_As_int(obj0));
12661 if (SWIG_arg_fail(1)) SWIG_fail;
12662 }
12663 }
12664 if (obj1) {
12665 {
12666 arg2 = (int)(SWIG_As_int(obj1));
12667 if (SWIG_arg_fail(2)) SWIG_fail;
12668 }
12669 }
12670 if (obj2) {
12671 {
12672 arg3 = (int)(SWIG_As_int(obj2));
12673 if (SWIG_arg_fail(3)) SWIG_fail;
12674 }
12675 }
12676 if (obj3) {
12677 {
12678 arg4 = (int)(SWIG_As_int(obj3));
12679 if (SWIG_arg_fail(4)) SWIG_fail;
12680 }
12681 }
12682 {
12683 PyThreadState* __tstate = wxPyBeginAllowThreads();
12684 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12685
12686 wxPyEndAllowThreads(__tstate);
12687 if (PyErr_Occurred()) SWIG_fail;
12688 }
12689 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12690 return resultobj;
12691 fail:
12692 return NULL;
12693 }
12694
12695
12696 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12697 PyObject *resultobj;
12698 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12699 wxPoint result;
12700 PyObject * obj0 = 0 ;
12701 char *kwnames[] = {
12702 (char *) "self", NULL
12703 };
12704
12705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12707 if (SWIG_arg_fail(1)) SWIG_fail;
12708 {
12709 PyThreadState* __tstate = wxPyBeginAllowThreads();
12710 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12711
12712 wxPyEndAllowThreads(__tstate);
12713 if (PyErr_Occurred()) SWIG_fail;
12714 }
12715 {
12716 wxPoint * resultptr;
12717 resultptr = new wxPoint((wxPoint &)(result));
12718 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12719 }
12720 return resultobj;
12721 fail:
12722 return NULL;
12723 }
12724
12725
12726 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12727 PyObject *resultobj;
12728 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12729 int result;
12730 PyObject * obj0 = 0 ;
12731 char *kwnames[] = {
12732 (char *) "self", NULL
12733 };
12734
12735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12737 if (SWIG_arg_fail(1)) SWIG_fail;
12738 {
12739 PyThreadState* __tstate = wxPyBeginAllowThreads();
12740 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12741
12742 wxPyEndAllowThreads(__tstate);
12743 if (PyErr_Occurred()) SWIG_fail;
12744 }
12745 {
12746 resultobj = SWIG_From_int((int)(result));
12747 }
12748 return resultobj;
12749 fail:
12750 return NULL;
12751 }
12752
12753
12754 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12755 PyObject *resultobj;
12756 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12757 int result;
12758 PyObject * obj0 = 0 ;
12759 char *kwnames[] = {
12760 (char *) "self", NULL
12761 };
12762
12763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12765 if (SWIG_arg_fail(1)) SWIG_fail;
12766 {
12767 PyThreadState* __tstate = wxPyBeginAllowThreads();
12768 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12769
12770 wxPyEndAllowThreads(__tstate);
12771 if (PyErr_Occurred()) SWIG_fail;
12772 }
12773 {
12774 resultobj = SWIG_From_int((int)(result));
12775 }
12776 return resultobj;
12777 fail:
12778 return NULL;
12779 }
12780
12781
12782 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12783 PyObject *resultobj;
12784 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12785 int result;
12786 PyObject * obj0 = 0 ;
12787 char *kwnames[] = {
12788 (char *) "self", NULL
12789 };
12790
12791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12793 if (SWIG_arg_fail(1)) SWIG_fail;
12794 {
12795 PyThreadState* __tstate = wxPyBeginAllowThreads();
12796 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12797
12798 wxPyEndAllowThreads(__tstate);
12799 if (PyErr_Occurred()) SWIG_fail;
12800 }
12801 {
12802 resultobj = SWIG_From_int((int)(result));
12803 }
12804 return resultobj;
12805 fail:
12806 return NULL;
12807 }
12808
12809
12810 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12811 PyObject *resultobj;
12812 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12813 int result;
12814 PyObject * obj0 = 0 ;
12815 char *kwnames[] = {
12816 (char *) "self", NULL
12817 };
12818
12819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12821 if (SWIG_arg_fail(1)) SWIG_fail;
12822 {
12823 PyThreadState* __tstate = wxPyBeginAllowThreads();
12824 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12825
12826 wxPyEndAllowThreads(__tstate);
12827 if (PyErr_Occurred()) SWIG_fail;
12828 }
12829 {
12830 resultobj = SWIG_From_int((int)(result));
12831 }
12832 return resultobj;
12833 fail:
12834 return NULL;
12835 }
12836
12837
12838 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12839 PyObject *resultobj;
12840 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12841 int arg2 ;
12842 PyObject * obj0 = 0 ;
12843 PyObject * obj1 = 0 ;
12844 char *kwnames[] = {
12845 (char *) "self",(char *) "stick", NULL
12846 };
12847
12848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12850 if (SWIG_arg_fail(1)) SWIG_fail;
12851 {
12852 arg2 = (int)(SWIG_As_int(obj1));
12853 if (SWIG_arg_fail(2)) SWIG_fail;
12854 }
12855 {
12856 PyThreadState* __tstate = wxPyBeginAllowThreads();
12857 (arg1)->SetJoystick(arg2);
12858
12859 wxPyEndAllowThreads(__tstate);
12860 if (PyErr_Occurred()) SWIG_fail;
12861 }
12862 Py_INCREF(Py_None); resultobj = Py_None;
12863 return resultobj;
12864 fail:
12865 return NULL;
12866 }
12867
12868
12869 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12870 PyObject *resultobj;
12871 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12872 int arg2 ;
12873 PyObject * obj0 = 0 ;
12874 PyObject * obj1 = 0 ;
12875 char *kwnames[] = {
12876 (char *) "self",(char *) "state", NULL
12877 };
12878
12879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
12880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12881 if (SWIG_arg_fail(1)) SWIG_fail;
12882 {
12883 arg2 = (int)(SWIG_As_int(obj1));
12884 if (SWIG_arg_fail(2)) SWIG_fail;
12885 }
12886 {
12887 PyThreadState* __tstate = wxPyBeginAllowThreads();
12888 (arg1)->SetButtonState(arg2);
12889
12890 wxPyEndAllowThreads(__tstate);
12891 if (PyErr_Occurred()) SWIG_fail;
12892 }
12893 Py_INCREF(Py_None); resultobj = Py_None;
12894 return resultobj;
12895 fail:
12896 return NULL;
12897 }
12898
12899
12900 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12901 PyObject *resultobj;
12902 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12903 int arg2 ;
12904 PyObject * obj0 = 0 ;
12905 PyObject * obj1 = 0 ;
12906 char *kwnames[] = {
12907 (char *) "self",(char *) "change", NULL
12908 };
12909
12910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
12911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12912 if (SWIG_arg_fail(1)) SWIG_fail;
12913 {
12914 arg2 = (int)(SWIG_As_int(obj1));
12915 if (SWIG_arg_fail(2)) SWIG_fail;
12916 }
12917 {
12918 PyThreadState* __tstate = wxPyBeginAllowThreads();
12919 (arg1)->SetButtonChange(arg2);
12920
12921 wxPyEndAllowThreads(__tstate);
12922 if (PyErr_Occurred()) SWIG_fail;
12923 }
12924 Py_INCREF(Py_None); resultobj = Py_None;
12925 return resultobj;
12926 fail:
12927 return NULL;
12928 }
12929
12930
12931 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12932 PyObject *resultobj;
12933 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12934 wxPoint *arg2 = 0 ;
12935 wxPoint temp2 ;
12936 PyObject * obj0 = 0 ;
12937 PyObject * obj1 = 0 ;
12938 char *kwnames[] = {
12939 (char *) "self",(char *) "pos", NULL
12940 };
12941
12942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
12943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12944 if (SWIG_arg_fail(1)) SWIG_fail;
12945 {
12946 arg2 = &temp2;
12947 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12948 }
12949 {
12950 PyThreadState* __tstate = wxPyBeginAllowThreads();
12951 (arg1)->SetPosition((wxPoint const &)*arg2);
12952
12953 wxPyEndAllowThreads(__tstate);
12954 if (PyErr_Occurred()) SWIG_fail;
12955 }
12956 Py_INCREF(Py_None); resultobj = Py_None;
12957 return resultobj;
12958 fail:
12959 return NULL;
12960 }
12961
12962
12963 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12964 PyObject *resultobj;
12965 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12966 int arg2 ;
12967 PyObject * obj0 = 0 ;
12968 PyObject * obj1 = 0 ;
12969 char *kwnames[] = {
12970 (char *) "self",(char *) "zPos", NULL
12971 };
12972
12973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
12974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12975 if (SWIG_arg_fail(1)) SWIG_fail;
12976 {
12977 arg2 = (int)(SWIG_As_int(obj1));
12978 if (SWIG_arg_fail(2)) SWIG_fail;
12979 }
12980 {
12981 PyThreadState* __tstate = wxPyBeginAllowThreads();
12982 (arg1)->SetZPosition(arg2);
12983
12984 wxPyEndAllowThreads(__tstate);
12985 if (PyErr_Occurred()) SWIG_fail;
12986 }
12987 Py_INCREF(Py_None); resultobj = Py_None;
12988 return resultobj;
12989 fail:
12990 return NULL;
12991 }
12992
12993
12994 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
12995 PyObject *resultobj;
12996 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12997 bool result;
12998 PyObject * obj0 = 0 ;
12999 char *kwnames[] = {
13000 (char *) "self", NULL
13001 };
13002
13003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13005 if (SWIG_arg_fail(1)) SWIG_fail;
13006 {
13007 PyThreadState* __tstate = wxPyBeginAllowThreads();
13008 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13009
13010 wxPyEndAllowThreads(__tstate);
13011 if (PyErr_Occurred()) SWIG_fail;
13012 }
13013 {
13014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13015 }
13016 return resultobj;
13017 fail:
13018 return NULL;
13019 }
13020
13021
13022 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13023 PyObject *resultobj;
13024 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13025 bool result;
13026 PyObject * obj0 = 0 ;
13027 char *kwnames[] = {
13028 (char *) "self", NULL
13029 };
13030
13031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13033 if (SWIG_arg_fail(1)) SWIG_fail;
13034 {
13035 PyThreadState* __tstate = wxPyBeginAllowThreads();
13036 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13037
13038 wxPyEndAllowThreads(__tstate);
13039 if (PyErr_Occurred()) SWIG_fail;
13040 }
13041 {
13042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13043 }
13044 return resultobj;
13045 fail:
13046 return NULL;
13047 }
13048
13049
13050 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13051 PyObject *resultobj;
13052 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13053 bool result;
13054 PyObject * obj0 = 0 ;
13055 char *kwnames[] = {
13056 (char *) "self", NULL
13057 };
13058
13059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13061 if (SWIG_arg_fail(1)) SWIG_fail;
13062 {
13063 PyThreadState* __tstate = wxPyBeginAllowThreads();
13064 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13065
13066 wxPyEndAllowThreads(__tstate);
13067 if (PyErr_Occurred()) SWIG_fail;
13068 }
13069 {
13070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13071 }
13072 return resultobj;
13073 fail:
13074 return NULL;
13075 }
13076
13077
13078 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13079 PyObject *resultobj;
13080 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13081 int arg2 = (int) wxJOY_BUTTON_ANY ;
13082 bool result;
13083 PyObject * obj0 = 0 ;
13084 PyObject * obj1 = 0 ;
13085 char *kwnames[] = {
13086 (char *) "self",(char *) "but", NULL
13087 };
13088
13089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13091 if (SWIG_arg_fail(1)) SWIG_fail;
13092 if (obj1) {
13093 {
13094 arg2 = (int)(SWIG_As_int(obj1));
13095 if (SWIG_arg_fail(2)) SWIG_fail;
13096 }
13097 }
13098 {
13099 PyThreadState* __tstate = wxPyBeginAllowThreads();
13100 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13101
13102 wxPyEndAllowThreads(__tstate);
13103 if (PyErr_Occurred()) SWIG_fail;
13104 }
13105 {
13106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13107 }
13108 return resultobj;
13109 fail:
13110 return NULL;
13111 }
13112
13113
13114 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13115 PyObject *resultobj;
13116 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13117 int arg2 = (int) wxJOY_BUTTON_ANY ;
13118 bool result;
13119 PyObject * obj0 = 0 ;
13120 PyObject * obj1 = 0 ;
13121 char *kwnames[] = {
13122 (char *) "self",(char *) "but", NULL
13123 };
13124
13125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13127 if (SWIG_arg_fail(1)) SWIG_fail;
13128 if (obj1) {
13129 {
13130 arg2 = (int)(SWIG_As_int(obj1));
13131 if (SWIG_arg_fail(2)) SWIG_fail;
13132 }
13133 }
13134 {
13135 PyThreadState* __tstate = wxPyBeginAllowThreads();
13136 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13137
13138 wxPyEndAllowThreads(__tstate);
13139 if (PyErr_Occurred()) SWIG_fail;
13140 }
13141 {
13142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13143 }
13144 return resultobj;
13145 fail:
13146 return NULL;
13147 }
13148
13149
13150 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13151 PyObject *resultobj;
13152 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13153 int arg2 = (int) wxJOY_BUTTON_ANY ;
13154 bool result;
13155 PyObject * obj0 = 0 ;
13156 PyObject * obj1 = 0 ;
13157 char *kwnames[] = {
13158 (char *) "self",(char *) "but", NULL
13159 };
13160
13161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13163 if (SWIG_arg_fail(1)) SWIG_fail;
13164 if (obj1) {
13165 {
13166 arg2 = (int)(SWIG_As_int(obj1));
13167 if (SWIG_arg_fail(2)) SWIG_fail;
13168 }
13169 }
13170 {
13171 PyThreadState* __tstate = wxPyBeginAllowThreads();
13172 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13173
13174 wxPyEndAllowThreads(__tstate);
13175 if (PyErr_Occurred()) SWIG_fail;
13176 }
13177 {
13178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13179 }
13180 return resultobj;
13181 fail:
13182 return NULL;
13183 }
13184
13185
13186 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13187 PyObject *obj;
13188 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13189 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13190 Py_INCREF(obj);
13191 return Py_BuildValue((char *)"");
13192 }
13193 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13194 PyObject *resultobj;
13195 wxString const &arg1_defvalue = wxPyEmptyString ;
13196 wxString *arg1 = (wxString *) &arg1_defvalue ;
13197 wxSound *result;
13198 bool temp1 = false ;
13199 PyObject * obj0 = 0 ;
13200 char *kwnames[] = {
13201 (char *) "fileName", NULL
13202 };
13203
13204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13205 if (obj0) {
13206 {
13207 arg1 = wxString_in_helper(obj0);
13208 if (arg1 == NULL) SWIG_fail;
13209 temp1 = true;
13210 }
13211 }
13212 {
13213 if (!wxPyCheckForApp()) SWIG_fail;
13214 PyThreadState* __tstate = wxPyBeginAllowThreads();
13215 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13216
13217 wxPyEndAllowThreads(__tstate);
13218 if (PyErr_Occurred()) SWIG_fail;
13219 }
13220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13221 {
13222 if (temp1)
13223 delete arg1;
13224 }
13225 return resultobj;
13226 fail:
13227 {
13228 if (temp1)
13229 delete arg1;
13230 }
13231 return NULL;
13232 }
13233
13234
13235 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13236 PyObject *resultobj;
13237 PyObject *arg1 = (PyObject *) 0 ;
13238 wxSound *result;
13239 PyObject * obj0 = 0 ;
13240 char *kwnames[] = {
13241 (char *) "data", NULL
13242 };
13243
13244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13245 arg1 = obj0;
13246 {
13247 if (!wxPyCheckForApp()) SWIG_fail;
13248 PyThreadState* __tstate = wxPyBeginAllowThreads();
13249 result = (wxSound *)new_wxSound(arg1);
13250
13251 wxPyEndAllowThreads(__tstate);
13252 if (PyErr_Occurred()) SWIG_fail;
13253 }
13254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13255 return resultobj;
13256 fail:
13257 return NULL;
13258 }
13259
13260
13261 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13262 PyObject *resultobj;
13263 wxSound *arg1 = (wxSound *) 0 ;
13264 PyObject * obj0 = 0 ;
13265 char *kwnames[] = {
13266 (char *) "self", NULL
13267 };
13268
13269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13271 if (SWIG_arg_fail(1)) SWIG_fail;
13272 {
13273 PyThreadState* __tstate = wxPyBeginAllowThreads();
13274 delete arg1;
13275
13276 wxPyEndAllowThreads(__tstate);
13277 if (PyErr_Occurred()) SWIG_fail;
13278 }
13279 Py_INCREF(Py_None); resultobj = Py_None;
13280 return resultobj;
13281 fail:
13282 return NULL;
13283 }
13284
13285
13286 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13287 PyObject *resultobj;
13288 wxSound *arg1 = (wxSound *) 0 ;
13289 wxString *arg2 = 0 ;
13290 bool result;
13291 bool temp2 = false ;
13292 PyObject * obj0 = 0 ;
13293 PyObject * obj1 = 0 ;
13294 char *kwnames[] = {
13295 (char *) "self",(char *) "fileName", NULL
13296 };
13297
13298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13300 if (SWIG_arg_fail(1)) SWIG_fail;
13301 {
13302 arg2 = wxString_in_helper(obj1);
13303 if (arg2 == NULL) SWIG_fail;
13304 temp2 = true;
13305 }
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 result = (bool)(arg1)->Create((wxString const &)*arg2);
13309
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 {
13314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13315 }
13316 {
13317 if (temp2)
13318 delete arg2;
13319 }
13320 return resultobj;
13321 fail:
13322 {
13323 if (temp2)
13324 delete arg2;
13325 }
13326 return NULL;
13327 }
13328
13329
13330 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13331 PyObject *resultobj;
13332 wxSound *arg1 = (wxSound *) 0 ;
13333 PyObject *arg2 = (PyObject *) 0 ;
13334 bool result;
13335 PyObject * obj0 = 0 ;
13336 PyObject * obj1 = 0 ;
13337 char *kwnames[] = {
13338 (char *) "self",(char *) "data", NULL
13339 };
13340
13341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13343 if (SWIG_arg_fail(1)) SWIG_fail;
13344 arg2 = obj1;
13345 {
13346 PyThreadState* __tstate = wxPyBeginAllowThreads();
13347 result = (bool)wxSound_CreateFromData(arg1,arg2);
13348
13349 wxPyEndAllowThreads(__tstate);
13350 if (PyErr_Occurred()) SWIG_fail;
13351 }
13352 {
13353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13354 }
13355 return resultobj;
13356 fail:
13357 return NULL;
13358 }
13359
13360
13361 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13362 PyObject *resultobj;
13363 wxSound *arg1 = (wxSound *) 0 ;
13364 bool result;
13365 PyObject * obj0 = 0 ;
13366 char *kwnames[] = {
13367 (char *) "self", NULL
13368 };
13369
13370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13372 if (SWIG_arg_fail(1)) SWIG_fail;
13373 {
13374 PyThreadState* __tstate = wxPyBeginAllowThreads();
13375 result = (bool)(arg1)->IsOk();
13376
13377 wxPyEndAllowThreads(__tstate);
13378 if (PyErr_Occurred()) SWIG_fail;
13379 }
13380 {
13381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13382 }
13383 return resultobj;
13384 fail:
13385 return NULL;
13386 }
13387
13388
13389 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13390 PyObject *resultobj;
13391 wxSound *arg1 = (wxSound *) 0 ;
13392 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13393 bool result;
13394 PyObject * obj0 = 0 ;
13395 PyObject * obj1 = 0 ;
13396 char *kwnames[] = {
13397 (char *) "self",(char *) "flags", NULL
13398 };
13399
13400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13402 if (SWIG_arg_fail(1)) SWIG_fail;
13403 if (obj1) {
13404 {
13405 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13406 if (SWIG_arg_fail(2)) SWIG_fail;
13407 }
13408 }
13409 {
13410 if (!wxPyCheckForApp()) SWIG_fail;
13411 PyThreadState* __tstate = wxPyBeginAllowThreads();
13412 result = (bool)((wxSound const *)arg1)->Play(arg2);
13413
13414 wxPyEndAllowThreads(__tstate);
13415 if (PyErr_Occurred()) SWIG_fail;
13416 }
13417 {
13418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13419 }
13420 return resultobj;
13421 fail:
13422 return NULL;
13423 }
13424
13425
13426 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13427 PyObject *resultobj;
13428 wxString *arg1 = 0 ;
13429 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13430 bool result;
13431 bool temp1 = false ;
13432 PyObject * obj0 = 0 ;
13433 PyObject * obj1 = 0 ;
13434 char *kwnames[] = {
13435 (char *) "filename",(char *) "flags", NULL
13436 };
13437
13438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13439 {
13440 arg1 = wxString_in_helper(obj0);
13441 if (arg1 == NULL) SWIG_fail;
13442 temp1 = true;
13443 }
13444 if (obj1) {
13445 {
13446 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13447 if (SWIG_arg_fail(2)) SWIG_fail;
13448 }
13449 }
13450 {
13451 if (!wxPyCheckForApp()) SWIG_fail;
13452 PyThreadState* __tstate = wxPyBeginAllowThreads();
13453 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13454
13455 wxPyEndAllowThreads(__tstate);
13456 if (PyErr_Occurred()) SWIG_fail;
13457 }
13458 {
13459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13460 }
13461 {
13462 if (temp1)
13463 delete arg1;
13464 }
13465 return resultobj;
13466 fail:
13467 {
13468 if (temp1)
13469 delete arg1;
13470 }
13471 return NULL;
13472 }
13473
13474
13475 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13476 PyObject *resultobj;
13477 char *kwnames[] = {
13478 NULL
13479 };
13480
13481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13482 {
13483 if (!wxPyCheckForApp()) SWIG_fail;
13484 PyThreadState* __tstate = wxPyBeginAllowThreads();
13485 wxSound::Stop();
13486
13487 wxPyEndAllowThreads(__tstate);
13488 if (PyErr_Occurred()) SWIG_fail;
13489 }
13490 Py_INCREF(Py_None); resultobj = Py_None;
13491 return resultobj;
13492 fail:
13493 return NULL;
13494 }
13495
13496
13497 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13498 PyObject *obj;
13499 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13500 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13501 Py_INCREF(obj);
13502 return Py_BuildValue((char *)"");
13503 }
13504 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13505 PyObject *resultobj;
13506 wxString *arg1 = 0 ;
13507 wxString *arg2 = 0 ;
13508 wxString *arg3 = 0 ;
13509 wxString *arg4 = 0 ;
13510 wxFileTypeInfo *result;
13511 bool temp1 = false ;
13512 bool temp2 = false ;
13513 bool temp3 = false ;
13514 bool temp4 = false ;
13515 PyObject * obj0 = 0 ;
13516 PyObject * obj1 = 0 ;
13517 PyObject * obj2 = 0 ;
13518 PyObject * obj3 = 0 ;
13519 char *kwnames[] = {
13520 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13521 };
13522
13523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13524 {
13525 arg1 = wxString_in_helper(obj0);
13526 if (arg1 == NULL) SWIG_fail;
13527 temp1 = true;
13528 }
13529 {
13530 arg2 = wxString_in_helper(obj1);
13531 if (arg2 == NULL) SWIG_fail;
13532 temp2 = true;
13533 }
13534 {
13535 arg3 = wxString_in_helper(obj2);
13536 if (arg3 == NULL) SWIG_fail;
13537 temp3 = true;
13538 }
13539 {
13540 arg4 = wxString_in_helper(obj3);
13541 if (arg4 == NULL) SWIG_fail;
13542 temp4 = true;
13543 }
13544 {
13545 PyThreadState* __tstate = wxPyBeginAllowThreads();
13546 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13547
13548 wxPyEndAllowThreads(__tstate);
13549 if (PyErr_Occurred()) SWIG_fail;
13550 }
13551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13552 {
13553 if (temp1)
13554 delete arg1;
13555 }
13556 {
13557 if (temp2)
13558 delete arg2;
13559 }
13560 {
13561 if (temp3)
13562 delete arg3;
13563 }
13564 {
13565 if (temp4)
13566 delete arg4;
13567 }
13568 return resultobj;
13569 fail:
13570 {
13571 if (temp1)
13572 delete arg1;
13573 }
13574 {
13575 if (temp2)
13576 delete arg2;
13577 }
13578 {
13579 if (temp3)
13580 delete arg3;
13581 }
13582 {
13583 if (temp4)
13584 delete arg4;
13585 }
13586 return NULL;
13587 }
13588
13589
13590 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13591 PyObject *resultobj;
13592 wxArrayString *arg1 = 0 ;
13593 wxFileTypeInfo *result;
13594 bool temp1 = false ;
13595 PyObject * obj0 = 0 ;
13596 char *kwnames[] = {
13597 (char *) "sArray", NULL
13598 };
13599
13600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13601 {
13602 if (! PySequence_Check(obj0)) {
13603 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13604 SWIG_fail;
13605 }
13606 arg1 = new wxArrayString;
13607 temp1 = true;
13608 int i, len=PySequence_Length(obj0);
13609 for (i=0; i<len; i++) {
13610 PyObject* item = PySequence_GetItem(obj0, i);
13611 #if wxUSE_UNICODE
13612 PyObject* str = PyObject_Unicode(item);
13613 #else
13614 PyObject* str = PyObject_Str(item);
13615 #endif
13616 if (PyErr_Occurred()) SWIG_fail;
13617 arg1->Add(Py2wxString(str));
13618 Py_DECREF(item);
13619 Py_DECREF(str);
13620 }
13621 }
13622 {
13623 PyThreadState* __tstate = wxPyBeginAllowThreads();
13624 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13625
13626 wxPyEndAllowThreads(__tstate);
13627 if (PyErr_Occurred()) SWIG_fail;
13628 }
13629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13630 {
13631 if (temp1) delete arg1;
13632 }
13633 return resultobj;
13634 fail:
13635 {
13636 if (temp1) delete arg1;
13637 }
13638 return NULL;
13639 }
13640
13641
13642 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13643 PyObject *resultobj;
13644 wxFileTypeInfo *result;
13645 char *kwnames[] = {
13646 NULL
13647 };
13648
13649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13650 {
13651 PyThreadState* __tstate = wxPyBeginAllowThreads();
13652 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13653
13654 wxPyEndAllowThreads(__tstate);
13655 if (PyErr_Occurred()) SWIG_fail;
13656 }
13657 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13658 return resultobj;
13659 fail:
13660 return NULL;
13661 }
13662
13663
13664 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13665 PyObject *resultobj;
13666 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13667 bool result;
13668 PyObject * obj0 = 0 ;
13669 char *kwnames[] = {
13670 (char *) "self", NULL
13671 };
13672
13673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13675 if (SWIG_arg_fail(1)) SWIG_fail;
13676 {
13677 PyThreadState* __tstate = wxPyBeginAllowThreads();
13678 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13679
13680 wxPyEndAllowThreads(__tstate);
13681 if (PyErr_Occurred()) SWIG_fail;
13682 }
13683 {
13684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13685 }
13686 return resultobj;
13687 fail:
13688 return NULL;
13689 }
13690
13691
13692 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13693 PyObject *resultobj;
13694 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13695 wxString *arg2 = 0 ;
13696 int arg3 = (int) 0 ;
13697 bool temp2 = false ;
13698 PyObject * obj0 = 0 ;
13699 PyObject * obj1 = 0 ;
13700 PyObject * obj2 = 0 ;
13701 char *kwnames[] = {
13702 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13703 };
13704
13705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13707 if (SWIG_arg_fail(1)) SWIG_fail;
13708 {
13709 arg2 = wxString_in_helper(obj1);
13710 if (arg2 == NULL) SWIG_fail;
13711 temp2 = true;
13712 }
13713 if (obj2) {
13714 {
13715 arg3 = (int)(SWIG_As_int(obj2));
13716 if (SWIG_arg_fail(3)) SWIG_fail;
13717 }
13718 }
13719 {
13720 PyThreadState* __tstate = wxPyBeginAllowThreads();
13721 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13722
13723 wxPyEndAllowThreads(__tstate);
13724 if (PyErr_Occurred()) SWIG_fail;
13725 }
13726 Py_INCREF(Py_None); resultobj = Py_None;
13727 {
13728 if (temp2)
13729 delete arg2;
13730 }
13731 return resultobj;
13732 fail:
13733 {
13734 if (temp2)
13735 delete arg2;
13736 }
13737 return NULL;
13738 }
13739
13740
13741 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13742 PyObject *resultobj;
13743 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13744 wxString *arg2 = 0 ;
13745 bool temp2 = false ;
13746 PyObject * obj0 = 0 ;
13747 PyObject * obj1 = 0 ;
13748 char *kwnames[] = {
13749 (char *) "self",(char *) "shortDesc", NULL
13750 };
13751
13752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13754 if (SWIG_arg_fail(1)) SWIG_fail;
13755 {
13756 arg2 = wxString_in_helper(obj1);
13757 if (arg2 == NULL) SWIG_fail;
13758 temp2 = true;
13759 }
13760 {
13761 PyThreadState* __tstate = wxPyBeginAllowThreads();
13762 (arg1)->SetShortDesc((wxString const &)*arg2);
13763
13764 wxPyEndAllowThreads(__tstate);
13765 if (PyErr_Occurred()) SWIG_fail;
13766 }
13767 Py_INCREF(Py_None); resultobj = Py_None;
13768 {
13769 if (temp2)
13770 delete arg2;
13771 }
13772 return resultobj;
13773 fail:
13774 {
13775 if (temp2)
13776 delete arg2;
13777 }
13778 return NULL;
13779 }
13780
13781
13782 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13783 PyObject *resultobj;
13784 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13785 wxString *result;
13786 PyObject * obj0 = 0 ;
13787 char *kwnames[] = {
13788 (char *) "self", NULL
13789 };
13790
13791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13793 if (SWIG_arg_fail(1)) SWIG_fail;
13794 {
13795 PyThreadState* __tstate = wxPyBeginAllowThreads();
13796 {
13797 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13798 result = (wxString *) &_result_ref;
13799 }
13800
13801 wxPyEndAllowThreads(__tstate);
13802 if (PyErr_Occurred()) SWIG_fail;
13803 }
13804 {
13805 #if wxUSE_UNICODE
13806 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13807 #else
13808 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13809 #endif
13810 }
13811 return resultobj;
13812 fail:
13813 return NULL;
13814 }
13815
13816
13817 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13818 PyObject *resultobj;
13819 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13820 wxString *result;
13821 PyObject * obj0 = 0 ;
13822 char *kwnames[] = {
13823 (char *) "self", NULL
13824 };
13825
13826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13828 if (SWIG_arg_fail(1)) SWIG_fail;
13829 {
13830 PyThreadState* __tstate = wxPyBeginAllowThreads();
13831 {
13832 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13833 result = (wxString *) &_result_ref;
13834 }
13835
13836 wxPyEndAllowThreads(__tstate);
13837 if (PyErr_Occurred()) SWIG_fail;
13838 }
13839 {
13840 #if wxUSE_UNICODE
13841 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13842 #else
13843 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13844 #endif
13845 }
13846 return resultobj;
13847 fail:
13848 return NULL;
13849 }
13850
13851
13852 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13853 PyObject *resultobj;
13854 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13855 wxString *result;
13856 PyObject * obj0 = 0 ;
13857 char *kwnames[] = {
13858 (char *) "self", NULL
13859 };
13860
13861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13863 if (SWIG_arg_fail(1)) SWIG_fail;
13864 {
13865 PyThreadState* __tstate = wxPyBeginAllowThreads();
13866 {
13867 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
13868 result = (wxString *) &_result_ref;
13869 }
13870
13871 wxPyEndAllowThreads(__tstate);
13872 if (PyErr_Occurred()) SWIG_fail;
13873 }
13874 {
13875 #if wxUSE_UNICODE
13876 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13877 #else
13878 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13879 #endif
13880 }
13881 return resultobj;
13882 fail:
13883 return NULL;
13884 }
13885
13886
13887 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13888 PyObject *resultobj;
13889 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13890 wxString *result;
13891 PyObject * obj0 = 0 ;
13892 char *kwnames[] = {
13893 (char *) "self", NULL
13894 };
13895
13896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
13897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13898 if (SWIG_arg_fail(1)) SWIG_fail;
13899 {
13900 PyThreadState* __tstate = wxPyBeginAllowThreads();
13901 {
13902 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
13903 result = (wxString *) &_result_ref;
13904 }
13905
13906 wxPyEndAllowThreads(__tstate);
13907 if (PyErr_Occurred()) SWIG_fail;
13908 }
13909 {
13910 #if wxUSE_UNICODE
13911 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13912 #else
13913 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13914 #endif
13915 }
13916 return resultobj;
13917 fail:
13918 return NULL;
13919 }
13920
13921
13922 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
13923 PyObject *resultobj;
13924 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13925 wxString *result;
13926 PyObject * obj0 = 0 ;
13927 char *kwnames[] = {
13928 (char *) "self", NULL
13929 };
13930
13931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
13932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13933 if (SWIG_arg_fail(1)) SWIG_fail;
13934 {
13935 PyThreadState* __tstate = wxPyBeginAllowThreads();
13936 {
13937 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
13938 result = (wxString *) &_result_ref;
13939 }
13940
13941 wxPyEndAllowThreads(__tstate);
13942 if (PyErr_Occurred()) SWIG_fail;
13943 }
13944 {
13945 #if wxUSE_UNICODE
13946 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13947 #else
13948 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13949 #endif
13950 }
13951 return resultobj;
13952 fail:
13953 return NULL;
13954 }
13955
13956
13957 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
13958 PyObject *resultobj;
13959 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13960 wxArrayString *result;
13961 PyObject * obj0 = 0 ;
13962 char *kwnames[] = {
13963 (char *) "self", NULL
13964 };
13965
13966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
13967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13968 if (SWIG_arg_fail(1)) SWIG_fail;
13969 {
13970 PyThreadState* __tstate = wxPyBeginAllowThreads();
13971 {
13972 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
13973 result = (wxArrayString *) &_result_ref;
13974 }
13975
13976 wxPyEndAllowThreads(__tstate);
13977 if (PyErr_Occurred()) SWIG_fail;
13978 }
13979 {
13980 resultobj = wxArrayString2PyList_helper(*result);
13981 }
13982 return resultobj;
13983 fail:
13984 return NULL;
13985 }
13986
13987
13988 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
13989 PyObject *resultobj;
13990 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13991 int result;
13992 PyObject * obj0 = 0 ;
13993 char *kwnames[] = {
13994 (char *) "self", NULL
13995 };
13996
13997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
13998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13999 if (SWIG_arg_fail(1)) SWIG_fail;
14000 {
14001 PyThreadState* __tstate = wxPyBeginAllowThreads();
14002 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14003
14004 wxPyEndAllowThreads(__tstate);
14005 if (PyErr_Occurred()) SWIG_fail;
14006 }
14007 {
14008 resultobj = SWIG_From_int((int)(result));
14009 }
14010 return resultobj;
14011 fail:
14012 return NULL;
14013 }
14014
14015
14016 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14017 PyObject *resultobj;
14018 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14019 wxString *result;
14020 PyObject * obj0 = 0 ;
14021 char *kwnames[] = {
14022 (char *) "self", NULL
14023 };
14024
14025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14027 if (SWIG_arg_fail(1)) SWIG_fail;
14028 {
14029 PyThreadState* __tstate = wxPyBeginAllowThreads();
14030 {
14031 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14032 result = (wxString *) &_result_ref;
14033 }
14034
14035 wxPyEndAllowThreads(__tstate);
14036 if (PyErr_Occurred()) SWIG_fail;
14037 }
14038 {
14039 #if wxUSE_UNICODE
14040 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14041 #else
14042 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14043 #endif
14044 }
14045 return resultobj;
14046 fail:
14047 return NULL;
14048 }
14049
14050
14051 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14052 PyObject *resultobj;
14053 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14054 int result;
14055 PyObject * obj0 = 0 ;
14056 char *kwnames[] = {
14057 (char *) "self", NULL
14058 };
14059
14060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14062 if (SWIG_arg_fail(1)) SWIG_fail;
14063 {
14064 PyThreadState* __tstate = wxPyBeginAllowThreads();
14065 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14066
14067 wxPyEndAllowThreads(__tstate);
14068 if (PyErr_Occurred()) SWIG_fail;
14069 }
14070 {
14071 resultobj = SWIG_From_int((int)(result));
14072 }
14073 return resultobj;
14074 fail:
14075 return NULL;
14076 }
14077
14078
14079 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14080 PyObject *obj;
14081 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14082 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14083 Py_INCREF(obj);
14084 return Py_BuildValue((char *)"");
14085 }
14086 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14087 PyObject *resultobj;
14088 wxFileTypeInfo *arg1 = 0 ;
14089 wxFileType *result;
14090 PyObject * obj0 = 0 ;
14091 char *kwnames[] = {
14092 (char *) "ftInfo", NULL
14093 };
14094
14095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14096 {
14097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14098 if (SWIG_arg_fail(1)) SWIG_fail;
14099 if (arg1 == NULL) {
14100 SWIG_null_ref("wxFileTypeInfo");
14101 }
14102 if (SWIG_arg_fail(1)) SWIG_fail;
14103 }
14104 {
14105 PyThreadState* __tstate = wxPyBeginAllowThreads();
14106 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14107
14108 wxPyEndAllowThreads(__tstate);
14109 if (PyErr_Occurred()) SWIG_fail;
14110 }
14111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14112 return resultobj;
14113 fail:
14114 return NULL;
14115 }
14116
14117
14118 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14119 PyObject *resultobj;
14120 wxFileType *arg1 = (wxFileType *) 0 ;
14121 PyObject * obj0 = 0 ;
14122 char *kwnames[] = {
14123 (char *) "self", NULL
14124 };
14125
14126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14128 if (SWIG_arg_fail(1)) SWIG_fail;
14129 {
14130 PyThreadState* __tstate = wxPyBeginAllowThreads();
14131 delete arg1;
14132
14133 wxPyEndAllowThreads(__tstate);
14134 if (PyErr_Occurred()) SWIG_fail;
14135 }
14136 Py_INCREF(Py_None); resultobj = Py_None;
14137 return resultobj;
14138 fail:
14139 return NULL;
14140 }
14141
14142
14143 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14144 PyObject *resultobj;
14145 wxFileType *arg1 = (wxFileType *) 0 ;
14146 PyObject *result;
14147 PyObject * obj0 = 0 ;
14148 char *kwnames[] = {
14149 (char *) "self", NULL
14150 };
14151
14152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14154 if (SWIG_arg_fail(1)) SWIG_fail;
14155 {
14156 PyThreadState* __tstate = wxPyBeginAllowThreads();
14157 result = (PyObject *)wxFileType_GetMimeType(arg1);
14158
14159 wxPyEndAllowThreads(__tstate);
14160 if (PyErr_Occurred()) SWIG_fail;
14161 }
14162 resultobj = result;
14163 return resultobj;
14164 fail:
14165 return NULL;
14166 }
14167
14168
14169 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14170 PyObject *resultobj;
14171 wxFileType *arg1 = (wxFileType *) 0 ;
14172 PyObject *result;
14173 PyObject * obj0 = 0 ;
14174 char *kwnames[] = {
14175 (char *) "self", NULL
14176 };
14177
14178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14180 if (SWIG_arg_fail(1)) SWIG_fail;
14181 {
14182 PyThreadState* __tstate = wxPyBeginAllowThreads();
14183 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14184
14185 wxPyEndAllowThreads(__tstate);
14186 if (PyErr_Occurred()) SWIG_fail;
14187 }
14188 resultobj = result;
14189 return resultobj;
14190 fail:
14191 return NULL;
14192 }
14193
14194
14195 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14196 PyObject *resultobj;
14197 wxFileType *arg1 = (wxFileType *) 0 ;
14198 PyObject *result;
14199 PyObject * obj0 = 0 ;
14200 char *kwnames[] = {
14201 (char *) "self", NULL
14202 };
14203
14204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14206 if (SWIG_arg_fail(1)) SWIG_fail;
14207 {
14208 PyThreadState* __tstate = wxPyBeginAllowThreads();
14209 result = (PyObject *)wxFileType_GetExtensions(arg1);
14210
14211 wxPyEndAllowThreads(__tstate);
14212 if (PyErr_Occurred()) SWIG_fail;
14213 }
14214 resultobj = result;
14215 return resultobj;
14216 fail:
14217 return NULL;
14218 }
14219
14220
14221 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14222 PyObject *resultobj;
14223 wxFileType *arg1 = (wxFileType *) 0 ;
14224 wxIcon *result;
14225 PyObject * obj0 = 0 ;
14226 char *kwnames[] = {
14227 (char *) "self", NULL
14228 };
14229
14230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14232 if (SWIG_arg_fail(1)) SWIG_fail;
14233 {
14234 PyThreadState* __tstate = wxPyBeginAllowThreads();
14235 result = (wxIcon *)wxFileType_GetIcon(arg1);
14236
14237 wxPyEndAllowThreads(__tstate);
14238 if (PyErr_Occurred()) SWIG_fail;
14239 }
14240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14241 return resultobj;
14242 fail:
14243 return NULL;
14244 }
14245
14246
14247 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14248 PyObject *resultobj;
14249 wxFileType *arg1 = (wxFileType *) 0 ;
14250 PyObject *result;
14251 PyObject * obj0 = 0 ;
14252 char *kwnames[] = {
14253 (char *) "self", NULL
14254 };
14255
14256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14258 if (SWIG_arg_fail(1)) SWIG_fail;
14259 {
14260 PyThreadState* __tstate = wxPyBeginAllowThreads();
14261 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14262
14263 wxPyEndAllowThreads(__tstate);
14264 if (PyErr_Occurred()) SWIG_fail;
14265 }
14266 resultobj = result;
14267 return resultobj;
14268 fail:
14269 return NULL;
14270 }
14271
14272
14273 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14274 PyObject *resultobj;
14275 wxFileType *arg1 = (wxFileType *) 0 ;
14276 PyObject *result;
14277 PyObject * obj0 = 0 ;
14278 char *kwnames[] = {
14279 (char *) "self", NULL
14280 };
14281
14282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14284 if (SWIG_arg_fail(1)) SWIG_fail;
14285 {
14286 PyThreadState* __tstate = wxPyBeginAllowThreads();
14287 result = (PyObject *)wxFileType_GetDescription(arg1);
14288
14289 wxPyEndAllowThreads(__tstate);
14290 if (PyErr_Occurred()) SWIG_fail;
14291 }
14292 resultobj = result;
14293 return resultobj;
14294 fail:
14295 return NULL;
14296 }
14297
14298
14299 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14300 PyObject *resultobj;
14301 wxFileType *arg1 = (wxFileType *) 0 ;
14302 wxString *arg2 = 0 ;
14303 wxString const &arg3_defvalue = wxPyEmptyString ;
14304 wxString *arg3 = (wxString *) &arg3_defvalue ;
14305 PyObject *result;
14306 bool temp2 = false ;
14307 bool temp3 = false ;
14308 PyObject * obj0 = 0 ;
14309 PyObject * obj1 = 0 ;
14310 PyObject * obj2 = 0 ;
14311 char *kwnames[] = {
14312 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14313 };
14314
14315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14317 if (SWIG_arg_fail(1)) SWIG_fail;
14318 {
14319 arg2 = wxString_in_helper(obj1);
14320 if (arg2 == NULL) SWIG_fail;
14321 temp2 = true;
14322 }
14323 if (obj2) {
14324 {
14325 arg3 = wxString_in_helper(obj2);
14326 if (arg3 == NULL) SWIG_fail;
14327 temp3 = true;
14328 }
14329 }
14330 {
14331 PyThreadState* __tstate = wxPyBeginAllowThreads();
14332 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14333
14334 wxPyEndAllowThreads(__tstate);
14335 if (PyErr_Occurred()) SWIG_fail;
14336 }
14337 resultobj = result;
14338 {
14339 if (temp2)
14340 delete arg2;
14341 }
14342 {
14343 if (temp3)
14344 delete arg3;
14345 }
14346 return resultobj;
14347 fail:
14348 {
14349 if (temp2)
14350 delete arg2;
14351 }
14352 {
14353 if (temp3)
14354 delete arg3;
14355 }
14356 return NULL;
14357 }
14358
14359
14360 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14361 PyObject *resultobj;
14362 wxFileType *arg1 = (wxFileType *) 0 ;
14363 wxString *arg2 = 0 ;
14364 wxString const &arg3_defvalue = wxPyEmptyString ;
14365 wxString *arg3 = (wxString *) &arg3_defvalue ;
14366 PyObject *result;
14367 bool temp2 = false ;
14368 bool temp3 = false ;
14369 PyObject * obj0 = 0 ;
14370 PyObject * obj1 = 0 ;
14371 PyObject * obj2 = 0 ;
14372 char *kwnames[] = {
14373 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14374 };
14375
14376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14378 if (SWIG_arg_fail(1)) SWIG_fail;
14379 {
14380 arg2 = wxString_in_helper(obj1);
14381 if (arg2 == NULL) SWIG_fail;
14382 temp2 = true;
14383 }
14384 if (obj2) {
14385 {
14386 arg3 = wxString_in_helper(obj2);
14387 if (arg3 == NULL) SWIG_fail;
14388 temp3 = true;
14389 }
14390 }
14391 {
14392 PyThreadState* __tstate = wxPyBeginAllowThreads();
14393 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14394
14395 wxPyEndAllowThreads(__tstate);
14396 if (PyErr_Occurred()) SWIG_fail;
14397 }
14398 resultobj = result;
14399 {
14400 if (temp2)
14401 delete arg2;
14402 }
14403 {
14404 if (temp3)
14405 delete arg3;
14406 }
14407 return resultobj;
14408 fail:
14409 {
14410 if (temp2)
14411 delete arg2;
14412 }
14413 {
14414 if (temp3)
14415 delete arg3;
14416 }
14417 return NULL;
14418 }
14419
14420
14421 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14422 PyObject *resultobj;
14423 wxFileType *arg1 = (wxFileType *) 0 ;
14424 wxString *arg2 = 0 ;
14425 wxString const &arg3_defvalue = wxPyEmptyString ;
14426 wxString *arg3 = (wxString *) &arg3_defvalue ;
14427 PyObject *result;
14428 bool temp2 = false ;
14429 bool temp3 = false ;
14430 PyObject * obj0 = 0 ;
14431 PyObject * obj1 = 0 ;
14432 PyObject * obj2 = 0 ;
14433 char *kwnames[] = {
14434 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14435 };
14436
14437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14439 if (SWIG_arg_fail(1)) SWIG_fail;
14440 {
14441 arg2 = wxString_in_helper(obj1);
14442 if (arg2 == NULL) SWIG_fail;
14443 temp2 = true;
14444 }
14445 if (obj2) {
14446 {
14447 arg3 = wxString_in_helper(obj2);
14448 if (arg3 == NULL) SWIG_fail;
14449 temp3 = true;
14450 }
14451 }
14452 {
14453 PyThreadState* __tstate = wxPyBeginAllowThreads();
14454 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14455
14456 wxPyEndAllowThreads(__tstate);
14457 if (PyErr_Occurred()) SWIG_fail;
14458 }
14459 resultobj = result;
14460 {
14461 if (temp2)
14462 delete arg2;
14463 }
14464 {
14465 if (temp3)
14466 delete arg3;
14467 }
14468 return resultobj;
14469 fail:
14470 {
14471 if (temp2)
14472 delete arg2;
14473 }
14474 {
14475 if (temp3)
14476 delete arg3;
14477 }
14478 return NULL;
14479 }
14480
14481
14482 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14483 PyObject *resultobj;
14484 wxFileType *arg1 = (wxFileType *) 0 ;
14485 wxString *arg2 = 0 ;
14486 wxString *arg3 = 0 ;
14487 bool arg4 = (bool) true ;
14488 bool result;
14489 bool temp2 = false ;
14490 bool temp3 = false ;
14491 PyObject * obj0 = 0 ;
14492 PyObject * obj1 = 0 ;
14493 PyObject * obj2 = 0 ;
14494 PyObject * obj3 = 0 ;
14495 char *kwnames[] = {
14496 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14497 };
14498
14499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14501 if (SWIG_arg_fail(1)) SWIG_fail;
14502 {
14503 arg2 = wxString_in_helper(obj1);
14504 if (arg2 == NULL) SWIG_fail;
14505 temp2 = true;
14506 }
14507 {
14508 arg3 = wxString_in_helper(obj2);
14509 if (arg3 == NULL) SWIG_fail;
14510 temp3 = true;
14511 }
14512 if (obj3) {
14513 {
14514 arg4 = (bool)(SWIG_As_bool(obj3));
14515 if (SWIG_arg_fail(4)) SWIG_fail;
14516 }
14517 }
14518 {
14519 PyThreadState* __tstate = wxPyBeginAllowThreads();
14520 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14521
14522 wxPyEndAllowThreads(__tstate);
14523 if (PyErr_Occurred()) SWIG_fail;
14524 }
14525 {
14526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14527 }
14528 {
14529 if (temp2)
14530 delete arg2;
14531 }
14532 {
14533 if (temp3)
14534 delete arg3;
14535 }
14536 return resultobj;
14537 fail:
14538 {
14539 if (temp2)
14540 delete arg2;
14541 }
14542 {
14543 if (temp3)
14544 delete arg3;
14545 }
14546 return NULL;
14547 }
14548
14549
14550 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14551 PyObject *resultobj;
14552 wxFileType *arg1 = (wxFileType *) 0 ;
14553 wxString const &arg2_defvalue = wxPyEmptyString ;
14554 wxString *arg2 = (wxString *) &arg2_defvalue ;
14555 int arg3 = (int) 0 ;
14556 bool result;
14557 bool temp2 = false ;
14558 PyObject * obj0 = 0 ;
14559 PyObject * obj1 = 0 ;
14560 PyObject * obj2 = 0 ;
14561 char *kwnames[] = {
14562 (char *) "self",(char *) "cmd",(char *) "index", NULL
14563 };
14564
14565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14567 if (SWIG_arg_fail(1)) SWIG_fail;
14568 if (obj1) {
14569 {
14570 arg2 = wxString_in_helper(obj1);
14571 if (arg2 == NULL) SWIG_fail;
14572 temp2 = true;
14573 }
14574 }
14575 if (obj2) {
14576 {
14577 arg3 = (int)(SWIG_As_int(obj2));
14578 if (SWIG_arg_fail(3)) SWIG_fail;
14579 }
14580 }
14581 {
14582 PyThreadState* __tstate = wxPyBeginAllowThreads();
14583 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14584
14585 wxPyEndAllowThreads(__tstate);
14586 if (PyErr_Occurred()) SWIG_fail;
14587 }
14588 {
14589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14590 }
14591 {
14592 if (temp2)
14593 delete arg2;
14594 }
14595 return resultobj;
14596 fail:
14597 {
14598 if (temp2)
14599 delete arg2;
14600 }
14601 return NULL;
14602 }
14603
14604
14605 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14606 PyObject *resultobj;
14607 wxFileType *arg1 = (wxFileType *) 0 ;
14608 bool result;
14609 PyObject * obj0 = 0 ;
14610 char *kwnames[] = {
14611 (char *) "self", NULL
14612 };
14613
14614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14616 if (SWIG_arg_fail(1)) SWIG_fail;
14617 {
14618 PyThreadState* __tstate = wxPyBeginAllowThreads();
14619 result = (bool)(arg1)->Unassociate();
14620
14621 wxPyEndAllowThreads(__tstate);
14622 if (PyErr_Occurred()) SWIG_fail;
14623 }
14624 {
14625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14626 }
14627 return resultobj;
14628 fail:
14629 return NULL;
14630 }
14631
14632
14633 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14634 PyObject *resultobj;
14635 wxString *arg1 = 0 ;
14636 wxString *arg2 = 0 ;
14637 wxString const &arg3_defvalue = wxPyEmptyString ;
14638 wxString *arg3 = (wxString *) &arg3_defvalue ;
14639 wxString result;
14640 bool temp1 = false ;
14641 bool temp2 = false ;
14642 bool temp3 = false ;
14643 PyObject * obj0 = 0 ;
14644 PyObject * obj1 = 0 ;
14645 PyObject * obj2 = 0 ;
14646 char *kwnames[] = {
14647 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14648 };
14649
14650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14651 {
14652 arg1 = wxString_in_helper(obj0);
14653 if (arg1 == NULL) SWIG_fail;
14654 temp1 = true;
14655 }
14656 {
14657 arg2 = wxString_in_helper(obj1);
14658 if (arg2 == NULL) SWIG_fail;
14659 temp2 = true;
14660 }
14661 if (obj2) {
14662 {
14663 arg3 = wxString_in_helper(obj2);
14664 if (arg3 == NULL) SWIG_fail;
14665 temp3 = true;
14666 }
14667 }
14668 {
14669 PyThreadState* __tstate = wxPyBeginAllowThreads();
14670 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14671
14672 wxPyEndAllowThreads(__tstate);
14673 if (PyErr_Occurred()) SWIG_fail;
14674 }
14675 {
14676 #if wxUSE_UNICODE
14677 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14678 #else
14679 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14680 #endif
14681 }
14682 {
14683 if (temp1)
14684 delete arg1;
14685 }
14686 {
14687 if (temp2)
14688 delete arg2;
14689 }
14690 {
14691 if (temp3)
14692 delete arg3;
14693 }
14694 return resultobj;
14695 fail:
14696 {
14697 if (temp1)
14698 delete arg1;
14699 }
14700 {
14701 if (temp2)
14702 delete arg2;
14703 }
14704 {
14705 if (temp3)
14706 delete arg3;
14707 }
14708 return NULL;
14709 }
14710
14711
14712 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14713 PyObject *obj;
14714 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14715 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14716 Py_INCREF(obj);
14717 return Py_BuildValue((char *)"");
14718 }
14719 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14720 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14721 return 1;
14722 }
14723
14724
14725 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14726 PyObject *pyobj;
14727
14728 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14729 return pyobj;
14730 }
14731
14732
14733 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14734 PyObject *resultobj;
14735 wxString *arg1 = 0 ;
14736 wxString *arg2 = 0 ;
14737 bool result;
14738 bool temp1 = false ;
14739 bool temp2 = false ;
14740 PyObject * obj0 = 0 ;
14741 PyObject * obj1 = 0 ;
14742 char *kwnames[] = {
14743 (char *) "mimeType",(char *) "wildcard", NULL
14744 };
14745
14746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14747 {
14748 arg1 = wxString_in_helper(obj0);
14749 if (arg1 == NULL) SWIG_fail;
14750 temp1 = true;
14751 }
14752 {
14753 arg2 = wxString_in_helper(obj1);
14754 if (arg2 == NULL) SWIG_fail;
14755 temp2 = true;
14756 }
14757 {
14758 PyThreadState* __tstate = wxPyBeginAllowThreads();
14759 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14760
14761 wxPyEndAllowThreads(__tstate);
14762 if (PyErr_Occurred()) SWIG_fail;
14763 }
14764 {
14765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14766 }
14767 {
14768 if (temp1)
14769 delete arg1;
14770 }
14771 {
14772 if (temp2)
14773 delete arg2;
14774 }
14775 return resultobj;
14776 fail:
14777 {
14778 if (temp1)
14779 delete arg1;
14780 }
14781 {
14782 if (temp2)
14783 delete arg2;
14784 }
14785 return NULL;
14786 }
14787
14788
14789 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14790 PyObject *resultobj;
14791 wxMimeTypesManager *result;
14792 char *kwnames[] = {
14793 NULL
14794 };
14795
14796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14797 {
14798 PyThreadState* __tstate = wxPyBeginAllowThreads();
14799 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14800
14801 wxPyEndAllowThreads(__tstate);
14802 if (PyErr_Occurred()) SWIG_fail;
14803 }
14804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14805 return resultobj;
14806 fail:
14807 return NULL;
14808 }
14809
14810
14811 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14812 PyObject *resultobj;
14813 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14814 int arg2 = (int) wxMAILCAP_ALL ;
14815 wxString const &arg3_defvalue = wxPyEmptyString ;
14816 wxString *arg3 = (wxString *) &arg3_defvalue ;
14817 bool temp3 = false ;
14818 PyObject * obj0 = 0 ;
14819 PyObject * obj1 = 0 ;
14820 PyObject * obj2 = 0 ;
14821 char *kwnames[] = {
14822 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14823 };
14824
14825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14827 if (SWIG_arg_fail(1)) SWIG_fail;
14828 if (obj1) {
14829 {
14830 arg2 = (int)(SWIG_As_int(obj1));
14831 if (SWIG_arg_fail(2)) SWIG_fail;
14832 }
14833 }
14834 if (obj2) {
14835 {
14836 arg3 = wxString_in_helper(obj2);
14837 if (arg3 == NULL) SWIG_fail;
14838 temp3 = true;
14839 }
14840 }
14841 {
14842 PyThreadState* __tstate = wxPyBeginAllowThreads();
14843 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14844
14845 wxPyEndAllowThreads(__tstate);
14846 if (PyErr_Occurred()) SWIG_fail;
14847 }
14848 Py_INCREF(Py_None); resultobj = Py_None;
14849 {
14850 if (temp3)
14851 delete arg3;
14852 }
14853 return resultobj;
14854 fail:
14855 {
14856 if (temp3)
14857 delete arg3;
14858 }
14859 return NULL;
14860 }
14861
14862
14863 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
14864 PyObject *resultobj;
14865 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14866 PyObject * obj0 = 0 ;
14867 char *kwnames[] = {
14868 (char *) "self", NULL
14869 };
14870
14871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
14872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14873 if (SWIG_arg_fail(1)) SWIG_fail;
14874 {
14875 PyThreadState* __tstate = wxPyBeginAllowThreads();
14876 (arg1)->ClearData();
14877
14878 wxPyEndAllowThreads(__tstate);
14879 if (PyErr_Occurred()) SWIG_fail;
14880 }
14881 Py_INCREF(Py_None); resultobj = Py_None;
14882 return resultobj;
14883 fail:
14884 return NULL;
14885 }
14886
14887
14888 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
14889 PyObject *resultobj;
14890 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14891 wxString *arg2 = 0 ;
14892 wxFileType *result;
14893 bool temp2 = false ;
14894 PyObject * obj0 = 0 ;
14895 PyObject * obj1 = 0 ;
14896 char *kwnames[] = {
14897 (char *) "self",(char *) "ext", NULL
14898 };
14899
14900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
14901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14902 if (SWIG_arg_fail(1)) SWIG_fail;
14903 {
14904 arg2 = wxString_in_helper(obj1);
14905 if (arg2 == NULL) SWIG_fail;
14906 temp2 = true;
14907 }
14908 {
14909 PyThreadState* __tstate = wxPyBeginAllowThreads();
14910 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
14911
14912 wxPyEndAllowThreads(__tstate);
14913 if (PyErr_Occurred()) SWIG_fail;
14914 }
14915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14916 {
14917 if (temp2)
14918 delete arg2;
14919 }
14920 return resultobj;
14921 fail:
14922 {
14923 if (temp2)
14924 delete arg2;
14925 }
14926 return NULL;
14927 }
14928
14929
14930 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14931 PyObject *resultobj;
14932 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14933 wxString *arg2 = 0 ;
14934 wxFileType *result;
14935 bool temp2 = false ;
14936 PyObject * obj0 = 0 ;
14937 PyObject * obj1 = 0 ;
14938 char *kwnames[] = {
14939 (char *) "self",(char *) "mimeType", NULL
14940 };
14941
14942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
14943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14944 if (SWIG_arg_fail(1)) SWIG_fail;
14945 {
14946 arg2 = wxString_in_helper(obj1);
14947 if (arg2 == NULL) SWIG_fail;
14948 temp2 = true;
14949 }
14950 {
14951 PyThreadState* __tstate = wxPyBeginAllowThreads();
14952 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
14953
14954 wxPyEndAllowThreads(__tstate);
14955 if (PyErr_Occurred()) SWIG_fail;
14956 }
14957 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14958 {
14959 if (temp2)
14960 delete arg2;
14961 }
14962 return resultobj;
14963 fail:
14964 {
14965 if (temp2)
14966 delete arg2;
14967 }
14968 return NULL;
14969 }
14970
14971
14972 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
14973 PyObject *resultobj;
14974 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14975 wxString *arg2 = 0 ;
14976 bool arg3 = (bool) false ;
14977 bool result;
14978 bool temp2 = false ;
14979 PyObject * obj0 = 0 ;
14980 PyObject * obj1 = 0 ;
14981 PyObject * obj2 = 0 ;
14982 char *kwnames[] = {
14983 (char *) "self",(char *) "filename",(char *) "fallback", NULL
14984 };
14985
14986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
14987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14988 if (SWIG_arg_fail(1)) SWIG_fail;
14989 {
14990 arg2 = wxString_in_helper(obj1);
14991 if (arg2 == NULL) SWIG_fail;
14992 temp2 = true;
14993 }
14994 if (obj2) {
14995 {
14996 arg3 = (bool)(SWIG_As_bool(obj2));
14997 if (SWIG_arg_fail(3)) SWIG_fail;
14998 }
14999 }
15000 {
15001 PyThreadState* __tstate = wxPyBeginAllowThreads();
15002 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15003
15004 wxPyEndAllowThreads(__tstate);
15005 if (PyErr_Occurred()) SWIG_fail;
15006 }
15007 {
15008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15009 }
15010 {
15011 if (temp2)
15012 delete arg2;
15013 }
15014 return resultobj;
15015 fail:
15016 {
15017 if (temp2)
15018 delete arg2;
15019 }
15020 return NULL;
15021 }
15022
15023
15024 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15025 PyObject *resultobj;
15026 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15027 wxString *arg2 = 0 ;
15028 bool result;
15029 bool temp2 = false ;
15030 PyObject * obj0 = 0 ;
15031 PyObject * obj1 = 0 ;
15032 char *kwnames[] = {
15033 (char *) "self",(char *) "filename", NULL
15034 };
15035
15036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15038 if (SWIG_arg_fail(1)) SWIG_fail;
15039 {
15040 arg2 = wxString_in_helper(obj1);
15041 if (arg2 == NULL) SWIG_fail;
15042 temp2 = true;
15043 }
15044 {
15045 PyThreadState* __tstate = wxPyBeginAllowThreads();
15046 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15047
15048 wxPyEndAllowThreads(__tstate);
15049 if (PyErr_Occurred()) SWIG_fail;
15050 }
15051 {
15052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15053 }
15054 {
15055 if (temp2)
15056 delete arg2;
15057 }
15058 return resultobj;
15059 fail:
15060 {
15061 if (temp2)
15062 delete arg2;
15063 }
15064 return NULL;
15065 }
15066
15067
15068 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15069 PyObject *resultobj;
15070 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15071 PyObject *result;
15072 PyObject * obj0 = 0 ;
15073 char *kwnames[] = {
15074 (char *) "self", NULL
15075 };
15076
15077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15079 if (SWIG_arg_fail(1)) SWIG_fail;
15080 {
15081 PyThreadState* __tstate = wxPyBeginAllowThreads();
15082 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15083
15084 wxPyEndAllowThreads(__tstate);
15085 if (PyErr_Occurred()) SWIG_fail;
15086 }
15087 resultobj = result;
15088 return resultobj;
15089 fail:
15090 return NULL;
15091 }
15092
15093
15094 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15095 PyObject *resultobj;
15096 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15097 wxFileTypeInfo *arg2 = 0 ;
15098 PyObject * obj0 = 0 ;
15099 PyObject * obj1 = 0 ;
15100 char *kwnames[] = {
15101 (char *) "self",(char *) "ft", NULL
15102 };
15103
15104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15106 if (SWIG_arg_fail(1)) SWIG_fail;
15107 {
15108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15109 if (SWIG_arg_fail(2)) SWIG_fail;
15110 if (arg2 == NULL) {
15111 SWIG_null_ref("wxFileTypeInfo");
15112 }
15113 if (SWIG_arg_fail(2)) SWIG_fail;
15114 }
15115 {
15116 PyThreadState* __tstate = wxPyBeginAllowThreads();
15117 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15118
15119 wxPyEndAllowThreads(__tstate);
15120 if (PyErr_Occurred()) SWIG_fail;
15121 }
15122 Py_INCREF(Py_None); resultobj = Py_None;
15123 return resultobj;
15124 fail:
15125 return NULL;
15126 }
15127
15128
15129 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15130 PyObject *resultobj;
15131 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15132 wxFileTypeInfo *arg2 = 0 ;
15133 wxFileType *result;
15134 PyObject * obj0 = 0 ;
15135 PyObject * obj1 = 0 ;
15136 char *kwnames[] = {
15137 (char *) "self",(char *) "ftInfo", NULL
15138 };
15139
15140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15142 if (SWIG_arg_fail(1)) SWIG_fail;
15143 {
15144 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15145 if (SWIG_arg_fail(2)) SWIG_fail;
15146 if (arg2 == NULL) {
15147 SWIG_null_ref("wxFileTypeInfo");
15148 }
15149 if (SWIG_arg_fail(2)) SWIG_fail;
15150 }
15151 {
15152 PyThreadState* __tstate = wxPyBeginAllowThreads();
15153 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15154
15155 wxPyEndAllowThreads(__tstate);
15156 if (PyErr_Occurred()) SWIG_fail;
15157 }
15158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15159 return resultobj;
15160 fail:
15161 return NULL;
15162 }
15163
15164
15165 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15166 PyObject *resultobj;
15167 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15168 wxFileType *arg2 = (wxFileType *) 0 ;
15169 bool result;
15170 PyObject * obj0 = 0 ;
15171 PyObject * obj1 = 0 ;
15172 char *kwnames[] = {
15173 (char *) "self",(char *) "ft", NULL
15174 };
15175
15176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15178 if (SWIG_arg_fail(1)) SWIG_fail;
15179 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15180 if (SWIG_arg_fail(2)) SWIG_fail;
15181 {
15182 PyThreadState* __tstate = wxPyBeginAllowThreads();
15183 result = (bool)(arg1)->Unassociate(arg2);
15184
15185 wxPyEndAllowThreads(__tstate);
15186 if (PyErr_Occurred()) SWIG_fail;
15187 }
15188 {
15189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15190 }
15191 return resultobj;
15192 fail:
15193 return NULL;
15194 }
15195
15196
15197 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15198 PyObject *resultobj;
15199 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15200 PyObject * obj0 = 0 ;
15201 char *kwnames[] = {
15202 (char *) "self", NULL
15203 };
15204
15205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15207 if (SWIG_arg_fail(1)) SWIG_fail;
15208 {
15209 PyThreadState* __tstate = wxPyBeginAllowThreads();
15210 delete arg1;
15211
15212 wxPyEndAllowThreads(__tstate);
15213 if (PyErr_Occurred()) SWIG_fail;
15214 }
15215 Py_INCREF(Py_None); resultobj = Py_None;
15216 return resultobj;
15217 fail:
15218 return NULL;
15219 }
15220
15221
15222 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15223 PyObject *obj;
15224 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15225 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15226 Py_INCREF(obj);
15227 return Py_BuildValue((char *)"");
15228 }
15229 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15230 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15231 return 1;
15232 }
15233
15234
15235 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15236 PyObject *pyobj;
15237
15238 {
15239 #if wxUSE_UNICODE
15240 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15241 #else
15242 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15243 #endif
15244 }
15245 return pyobj;
15246 }
15247
15248
15249 static int _wrap_ART_MENU_set(PyObject *) {
15250 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15251 return 1;
15252 }
15253
15254
15255 static PyObject *_wrap_ART_MENU_get(void) {
15256 PyObject *pyobj;
15257
15258 {
15259 #if wxUSE_UNICODE
15260 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15261 #else
15262 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15263 #endif
15264 }
15265 return pyobj;
15266 }
15267
15268
15269 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15270 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15271 return 1;
15272 }
15273
15274
15275 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15276 PyObject *pyobj;
15277
15278 {
15279 #if wxUSE_UNICODE
15280 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15281 #else
15282 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15283 #endif
15284 }
15285 return pyobj;
15286 }
15287
15288
15289 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15290 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15291 return 1;
15292 }
15293
15294
15295 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15296 PyObject *pyobj;
15297
15298 {
15299 #if wxUSE_UNICODE
15300 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15301 #else
15302 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15303 #endif
15304 }
15305 return pyobj;
15306 }
15307
15308
15309 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15310 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15311 return 1;
15312 }
15313
15314
15315 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15316 PyObject *pyobj;
15317
15318 {
15319 #if wxUSE_UNICODE
15320 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15321 #else
15322 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15323 #endif
15324 }
15325 return pyobj;
15326 }
15327
15328
15329 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15330 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15331 return 1;
15332 }
15333
15334
15335 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15336 PyObject *pyobj;
15337
15338 {
15339 #if wxUSE_UNICODE
15340 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15341 #else
15342 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15343 #endif
15344 }
15345 return pyobj;
15346 }
15347
15348
15349 static int _wrap_ART_BUTTON_set(PyObject *) {
15350 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15351 return 1;
15352 }
15353
15354
15355 static PyObject *_wrap_ART_BUTTON_get(void) {
15356 PyObject *pyobj;
15357
15358 {
15359 #if wxUSE_UNICODE
15360 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15361 #else
15362 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15363 #endif
15364 }
15365 return pyobj;
15366 }
15367
15368
15369 static int _wrap_ART_OTHER_set(PyObject *) {
15370 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15371 return 1;
15372 }
15373
15374
15375 static PyObject *_wrap_ART_OTHER_get(void) {
15376 PyObject *pyobj;
15377
15378 {
15379 #if wxUSE_UNICODE
15380 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15381 #else
15382 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15383 #endif
15384 }
15385 return pyobj;
15386 }
15387
15388
15389 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15390 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15391 return 1;
15392 }
15393
15394
15395 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15396 PyObject *pyobj;
15397
15398 {
15399 #if wxUSE_UNICODE
15400 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15401 #else
15402 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15403 #endif
15404 }
15405 return pyobj;
15406 }
15407
15408
15409 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15410 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15411 return 1;
15412 }
15413
15414
15415 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15416 PyObject *pyobj;
15417
15418 {
15419 #if wxUSE_UNICODE
15420 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15421 #else
15422 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15423 #endif
15424 }
15425 return pyobj;
15426 }
15427
15428
15429 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15430 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15431 return 1;
15432 }
15433
15434
15435 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15436 PyObject *pyobj;
15437
15438 {
15439 #if wxUSE_UNICODE
15440 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15441 #else
15442 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15443 #endif
15444 }
15445 return pyobj;
15446 }
15447
15448
15449 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15450 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15451 return 1;
15452 }
15453
15454
15455 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15456 PyObject *pyobj;
15457
15458 {
15459 #if wxUSE_UNICODE
15460 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15461 #else
15462 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15463 #endif
15464 }
15465 return pyobj;
15466 }
15467
15468
15469 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15470 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15471 return 1;
15472 }
15473
15474
15475 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15476 PyObject *pyobj;
15477
15478 {
15479 #if wxUSE_UNICODE
15480 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15481 #else
15482 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15483 #endif
15484 }
15485 return pyobj;
15486 }
15487
15488
15489 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15490 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15491 return 1;
15492 }
15493
15494
15495 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15496 PyObject *pyobj;
15497
15498 {
15499 #if wxUSE_UNICODE
15500 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15501 #else
15502 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15503 #endif
15504 }
15505 return pyobj;
15506 }
15507
15508
15509 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15510 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15511 return 1;
15512 }
15513
15514
15515 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15516 PyObject *pyobj;
15517
15518 {
15519 #if wxUSE_UNICODE
15520 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15521 #else
15522 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15523 #endif
15524 }
15525 return pyobj;
15526 }
15527
15528
15529 static int _wrap_ART_GO_BACK_set(PyObject *) {
15530 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15531 return 1;
15532 }
15533
15534
15535 static PyObject *_wrap_ART_GO_BACK_get(void) {
15536 PyObject *pyobj;
15537
15538 {
15539 #if wxUSE_UNICODE
15540 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15541 #else
15542 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15543 #endif
15544 }
15545 return pyobj;
15546 }
15547
15548
15549 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15550 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15551 return 1;
15552 }
15553
15554
15555 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15556 PyObject *pyobj;
15557
15558 {
15559 #if wxUSE_UNICODE
15560 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15561 #else
15562 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15563 #endif
15564 }
15565 return pyobj;
15566 }
15567
15568
15569 static int _wrap_ART_GO_UP_set(PyObject *) {
15570 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15571 return 1;
15572 }
15573
15574
15575 static PyObject *_wrap_ART_GO_UP_get(void) {
15576 PyObject *pyobj;
15577
15578 {
15579 #if wxUSE_UNICODE
15580 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15581 #else
15582 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15583 #endif
15584 }
15585 return pyobj;
15586 }
15587
15588
15589 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15590 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15591 return 1;
15592 }
15593
15594
15595 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15596 PyObject *pyobj;
15597
15598 {
15599 #if wxUSE_UNICODE
15600 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15601 #else
15602 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15603 #endif
15604 }
15605 return pyobj;
15606 }
15607
15608
15609 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15610 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15611 return 1;
15612 }
15613
15614
15615 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15616 PyObject *pyobj;
15617
15618 {
15619 #if wxUSE_UNICODE
15620 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15621 #else
15622 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15623 #endif
15624 }
15625 return pyobj;
15626 }
15627
15628
15629 static int _wrap_ART_GO_HOME_set(PyObject *) {
15630 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15631 return 1;
15632 }
15633
15634
15635 static PyObject *_wrap_ART_GO_HOME_get(void) {
15636 PyObject *pyobj;
15637
15638 {
15639 #if wxUSE_UNICODE
15640 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15641 #else
15642 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15643 #endif
15644 }
15645 return pyobj;
15646 }
15647
15648
15649 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15650 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15651 return 1;
15652 }
15653
15654
15655 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15656 PyObject *pyobj;
15657
15658 {
15659 #if wxUSE_UNICODE
15660 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15661 #else
15662 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15663 #endif
15664 }
15665 return pyobj;
15666 }
15667
15668
15669 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15670 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15671 return 1;
15672 }
15673
15674
15675 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15676 PyObject *pyobj;
15677
15678 {
15679 #if wxUSE_UNICODE
15680 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15681 #else
15682 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15683 #endif
15684 }
15685 return pyobj;
15686 }
15687
15688
15689 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15690 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15691 return 1;
15692 }
15693
15694
15695 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15696 PyObject *pyobj;
15697
15698 {
15699 #if wxUSE_UNICODE
15700 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15701 #else
15702 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15703 #endif
15704 }
15705 return pyobj;
15706 }
15707
15708
15709 static int _wrap_ART_PRINT_set(PyObject *) {
15710 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15711 return 1;
15712 }
15713
15714
15715 static PyObject *_wrap_ART_PRINT_get(void) {
15716 PyObject *pyobj;
15717
15718 {
15719 #if wxUSE_UNICODE
15720 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15721 #else
15722 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15723 #endif
15724 }
15725 return pyobj;
15726 }
15727
15728
15729 static int _wrap_ART_HELP_set(PyObject *) {
15730 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15731 return 1;
15732 }
15733
15734
15735 static PyObject *_wrap_ART_HELP_get(void) {
15736 PyObject *pyobj;
15737
15738 {
15739 #if wxUSE_UNICODE
15740 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15741 #else
15742 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15743 #endif
15744 }
15745 return pyobj;
15746 }
15747
15748
15749 static int _wrap_ART_TIP_set(PyObject *) {
15750 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15751 return 1;
15752 }
15753
15754
15755 static PyObject *_wrap_ART_TIP_get(void) {
15756 PyObject *pyobj;
15757
15758 {
15759 #if wxUSE_UNICODE
15760 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15761 #else
15762 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15763 #endif
15764 }
15765 return pyobj;
15766 }
15767
15768
15769 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15770 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15771 return 1;
15772 }
15773
15774
15775 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15776 PyObject *pyobj;
15777
15778 {
15779 #if wxUSE_UNICODE
15780 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15781 #else
15782 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15783 #endif
15784 }
15785 return pyobj;
15786 }
15787
15788
15789 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15790 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15791 return 1;
15792 }
15793
15794
15795 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15796 PyObject *pyobj;
15797
15798 {
15799 #if wxUSE_UNICODE
15800 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15801 #else
15802 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15803 #endif
15804 }
15805 return pyobj;
15806 }
15807
15808
15809 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15810 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15811 return 1;
15812 }
15813
15814
15815 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15816 PyObject *pyobj;
15817
15818 {
15819 #if wxUSE_UNICODE
15820 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15821 #else
15822 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15823 #endif
15824 }
15825 return pyobj;
15826 }
15827
15828
15829 static int _wrap_ART_HARDDISK_set(PyObject *) {
15830 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15831 return 1;
15832 }
15833
15834
15835 static PyObject *_wrap_ART_HARDDISK_get(void) {
15836 PyObject *pyobj;
15837
15838 {
15839 #if wxUSE_UNICODE
15840 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15841 #else
15842 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15843 #endif
15844 }
15845 return pyobj;
15846 }
15847
15848
15849 static int _wrap_ART_FLOPPY_set(PyObject *) {
15850 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15851 return 1;
15852 }
15853
15854
15855 static PyObject *_wrap_ART_FLOPPY_get(void) {
15856 PyObject *pyobj;
15857
15858 {
15859 #if wxUSE_UNICODE
15860 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15861 #else
15862 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15863 #endif
15864 }
15865 return pyobj;
15866 }
15867
15868
15869 static int _wrap_ART_CDROM_set(PyObject *) {
15870 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
15871 return 1;
15872 }
15873
15874
15875 static PyObject *_wrap_ART_CDROM_get(void) {
15876 PyObject *pyobj;
15877
15878 {
15879 #if wxUSE_UNICODE
15880 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15881 #else
15882 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15883 #endif
15884 }
15885 return pyobj;
15886 }
15887
15888
15889 static int _wrap_ART_REMOVABLE_set(PyObject *) {
15890 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
15891 return 1;
15892 }
15893
15894
15895 static PyObject *_wrap_ART_REMOVABLE_get(void) {
15896 PyObject *pyobj;
15897
15898 {
15899 #if wxUSE_UNICODE
15900 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15901 #else
15902 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15903 #endif
15904 }
15905 return pyobj;
15906 }
15907
15908
15909 static int _wrap_ART_FOLDER_set(PyObject *) {
15910 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
15911 return 1;
15912 }
15913
15914
15915 static PyObject *_wrap_ART_FOLDER_get(void) {
15916 PyObject *pyobj;
15917
15918 {
15919 #if wxUSE_UNICODE
15920 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15921 #else
15922 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15923 #endif
15924 }
15925 return pyobj;
15926 }
15927
15928
15929 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
15930 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
15931 return 1;
15932 }
15933
15934
15935 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
15936 PyObject *pyobj;
15937
15938 {
15939 #if wxUSE_UNICODE
15940 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15941 #else
15942 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15943 #endif
15944 }
15945 return pyobj;
15946 }
15947
15948
15949 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
15950 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
15951 return 1;
15952 }
15953
15954
15955 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
15956 PyObject *pyobj;
15957
15958 {
15959 #if wxUSE_UNICODE
15960 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15961 #else
15962 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15963 #endif
15964 }
15965 return pyobj;
15966 }
15967
15968
15969 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
15970 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
15971 return 1;
15972 }
15973
15974
15975 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
15976 PyObject *pyobj;
15977
15978 {
15979 #if wxUSE_UNICODE
15980 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15981 #else
15982 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15983 #endif
15984 }
15985 return pyobj;
15986 }
15987
15988
15989 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
15990 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
15991 return 1;
15992 }
15993
15994
15995 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
15996 PyObject *pyobj;
15997
15998 {
15999 #if wxUSE_UNICODE
16000 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16001 #else
16002 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16003 #endif
16004 }
16005 return pyobj;
16006 }
16007
16008
16009 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16010 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16011 return 1;
16012 }
16013
16014
16015 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16016 PyObject *pyobj;
16017
16018 {
16019 #if wxUSE_UNICODE
16020 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16021 #else
16022 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16023 #endif
16024 }
16025 return pyobj;
16026 }
16027
16028
16029 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16030 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16031 return 1;
16032 }
16033
16034
16035 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16036 PyObject *pyobj;
16037
16038 {
16039 #if wxUSE_UNICODE
16040 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16041 #else
16042 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16043 #endif
16044 }
16045 return pyobj;
16046 }
16047
16048
16049 static int _wrap_ART_ERROR_set(PyObject *) {
16050 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16051 return 1;
16052 }
16053
16054
16055 static PyObject *_wrap_ART_ERROR_get(void) {
16056 PyObject *pyobj;
16057
16058 {
16059 #if wxUSE_UNICODE
16060 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16061 #else
16062 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16063 #endif
16064 }
16065 return pyobj;
16066 }
16067
16068
16069 static int _wrap_ART_QUESTION_set(PyObject *) {
16070 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16071 return 1;
16072 }
16073
16074
16075 static PyObject *_wrap_ART_QUESTION_get(void) {
16076 PyObject *pyobj;
16077
16078 {
16079 #if wxUSE_UNICODE
16080 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16081 #else
16082 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16083 #endif
16084 }
16085 return pyobj;
16086 }
16087
16088
16089 static int _wrap_ART_WARNING_set(PyObject *) {
16090 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16091 return 1;
16092 }
16093
16094
16095 static PyObject *_wrap_ART_WARNING_get(void) {
16096 PyObject *pyobj;
16097
16098 {
16099 #if wxUSE_UNICODE
16100 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16101 #else
16102 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16103 #endif
16104 }
16105 return pyobj;
16106 }
16107
16108
16109 static int _wrap_ART_INFORMATION_set(PyObject *) {
16110 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16111 return 1;
16112 }
16113
16114
16115 static PyObject *_wrap_ART_INFORMATION_get(void) {
16116 PyObject *pyobj;
16117
16118 {
16119 #if wxUSE_UNICODE
16120 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16121 #else
16122 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16123 #endif
16124 }
16125 return pyobj;
16126 }
16127
16128
16129 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16130 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16131 return 1;
16132 }
16133
16134
16135 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16136 PyObject *pyobj;
16137
16138 {
16139 #if wxUSE_UNICODE
16140 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16141 #else
16142 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16143 #endif
16144 }
16145 return pyobj;
16146 }
16147
16148
16149 static int _wrap_ART_COPY_set(PyObject *) {
16150 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16151 return 1;
16152 }
16153
16154
16155 static PyObject *_wrap_ART_COPY_get(void) {
16156 PyObject *pyobj;
16157
16158 {
16159 #if wxUSE_UNICODE
16160 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16161 #else
16162 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16163 #endif
16164 }
16165 return pyobj;
16166 }
16167
16168
16169 static int _wrap_ART_CUT_set(PyObject *) {
16170 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16171 return 1;
16172 }
16173
16174
16175 static PyObject *_wrap_ART_CUT_get(void) {
16176 PyObject *pyobj;
16177
16178 {
16179 #if wxUSE_UNICODE
16180 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16181 #else
16182 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16183 #endif
16184 }
16185 return pyobj;
16186 }
16187
16188
16189 static int _wrap_ART_PASTE_set(PyObject *) {
16190 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16191 return 1;
16192 }
16193
16194
16195 static PyObject *_wrap_ART_PASTE_get(void) {
16196 PyObject *pyobj;
16197
16198 {
16199 #if wxUSE_UNICODE
16200 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16201 #else
16202 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16203 #endif
16204 }
16205 return pyobj;
16206 }
16207
16208
16209 static int _wrap_ART_DELETE_set(PyObject *) {
16210 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16211 return 1;
16212 }
16213
16214
16215 static PyObject *_wrap_ART_DELETE_get(void) {
16216 PyObject *pyobj;
16217
16218 {
16219 #if wxUSE_UNICODE
16220 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16221 #else
16222 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16223 #endif
16224 }
16225 return pyobj;
16226 }
16227
16228
16229 static int _wrap_ART_UNDO_set(PyObject *) {
16230 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16231 return 1;
16232 }
16233
16234
16235 static PyObject *_wrap_ART_UNDO_get(void) {
16236 PyObject *pyobj;
16237
16238 {
16239 #if wxUSE_UNICODE
16240 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16241 #else
16242 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16243 #endif
16244 }
16245 return pyobj;
16246 }
16247
16248
16249 static int _wrap_ART_REDO_set(PyObject *) {
16250 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16251 return 1;
16252 }
16253
16254
16255 static PyObject *_wrap_ART_REDO_get(void) {
16256 PyObject *pyobj;
16257
16258 {
16259 #if wxUSE_UNICODE
16260 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16261 #else
16262 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16263 #endif
16264 }
16265 return pyobj;
16266 }
16267
16268
16269 static int _wrap_ART_QUIT_set(PyObject *) {
16270 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16271 return 1;
16272 }
16273
16274
16275 static PyObject *_wrap_ART_QUIT_get(void) {
16276 PyObject *pyobj;
16277
16278 {
16279 #if wxUSE_UNICODE
16280 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16281 #else
16282 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16283 #endif
16284 }
16285 return pyobj;
16286 }
16287
16288
16289 static int _wrap_ART_FIND_set(PyObject *) {
16290 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16291 return 1;
16292 }
16293
16294
16295 static PyObject *_wrap_ART_FIND_get(void) {
16296 PyObject *pyobj;
16297
16298 {
16299 #if wxUSE_UNICODE
16300 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16301 #else
16302 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16303 #endif
16304 }
16305 return pyobj;
16306 }
16307
16308
16309 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16310 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16311 return 1;
16312 }
16313
16314
16315 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16316 PyObject *pyobj;
16317
16318 {
16319 #if wxUSE_UNICODE
16320 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16321 #else
16322 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16323 #endif
16324 }
16325 return pyobj;
16326 }
16327
16328
16329 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16330 PyObject *resultobj;
16331 wxPyArtProvider *result;
16332 char *kwnames[] = {
16333 NULL
16334 };
16335
16336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16337 {
16338 if (!wxPyCheckForApp()) SWIG_fail;
16339 PyThreadState* __tstate = wxPyBeginAllowThreads();
16340 result = (wxPyArtProvider *)new wxPyArtProvider();
16341
16342 wxPyEndAllowThreads(__tstate);
16343 if (PyErr_Occurred()) SWIG_fail;
16344 }
16345 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16346 return resultobj;
16347 fail:
16348 return NULL;
16349 }
16350
16351
16352 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16353 PyObject *resultobj;
16354 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16355 PyObject *arg2 = (PyObject *) 0 ;
16356 PyObject *arg3 = (PyObject *) 0 ;
16357 PyObject * obj0 = 0 ;
16358 PyObject * obj1 = 0 ;
16359 PyObject * obj2 = 0 ;
16360 char *kwnames[] = {
16361 (char *) "self",(char *) "self",(char *) "_class", NULL
16362 };
16363
16364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16366 if (SWIG_arg_fail(1)) SWIG_fail;
16367 arg2 = obj1;
16368 arg3 = obj2;
16369 {
16370 PyThreadState* __tstate = wxPyBeginAllowThreads();
16371 (arg1)->_setCallbackInfo(arg2,arg3);
16372
16373 wxPyEndAllowThreads(__tstate);
16374 if (PyErr_Occurred()) SWIG_fail;
16375 }
16376 Py_INCREF(Py_None); resultobj = Py_None;
16377 return resultobj;
16378 fail:
16379 return NULL;
16380 }
16381
16382
16383 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16384 PyObject *resultobj;
16385 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16386 PyObject * obj0 = 0 ;
16387 char *kwnames[] = {
16388 (char *) "provider", NULL
16389 };
16390
16391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16393 if (SWIG_arg_fail(1)) SWIG_fail;
16394 {
16395 PyThreadState* __tstate = wxPyBeginAllowThreads();
16396 wxPyArtProvider::PushProvider(arg1);
16397
16398 wxPyEndAllowThreads(__tstate);
16399 if (PyErr_Occurred()) SWIG_fail;
16400 }
16401 Py_INCREF(Py_None); resultobj = Py_None;
16402 return resultobj;
16403 fail:
16404 return NULL;
16405 }
16406
16407
16408 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16409 PyObject *resultobj;
16410 bool result;
16411 char *kwnames[] = {
16412 NULL
16413 };
16414
16415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16416 {
16417 PyThreadState* __tstate = wxPyBeginAllowThreads();
16418 result = (bool)wxPyArtProvider::PopProvider();
16419
16420 wxPyEndAllowThreads(__tstate);
16421 if (PyErr_Occurred()) SWIG_fail;
16422 }
16423 {
16424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16425 }
16426 return resultobj;
16427 fail:
16428 return NULL;
16429 }
16430
16431
16432 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16433 PyObject *resultobj;
16434 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16435 bool result;
16436 PyObject * obj0 = 0 ;
16437 char *kwnames[] = {
16438 (char *) "provider", NULL
16439 };
16440
16441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16443 if (SWIG_arg_fail(1)) SWIG_fail;
16444 {
16445 PyThreadState* __tstate = wxPyBeginAllowThreads();
16446 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16447
16448 wxPyEndAllowThreads(__tstate);
16449 if (PyErr_Occurred()) SWIG_fail;
16450 }
16451 {
16452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16453 }
16454 return resultobj;
16455 fail:
16456 return NULL;
16457 }
16458
16459
16460 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16461 PyObject *resultobj;
16462 wxString *arg1 = 0 ;
16463 wxString const &arg2_defvalue = wxPyART_OTHER ;
16464 wxString *arg2 = (wxString *) &arg2_defvalue ;
16465 wxSize const &arg3_defvalue = wxDefaultSize ;
16466 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16467 wxBitmap result;
16468 bool temp1 = false ;
16469 bool temp2 = false ;
16470 wxSize temp3 ;
16471 PyObject * obj0 = 0 ;
16472 PyObject * obj1 = 0 ;
16473 PyObject * obj2 = 0 ;
16474 char *kwnames[] = {
16475 (char *) "id",(char *) "client",(char *) "size", NULL
16476 };
16477
16478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16479 {
16480 arg1 = wxString_in_helper(obj0);
16481 if (arg1 == NULL) SWIG_fail;
16482 temp1 = true;
16483 }
16484 if (obj1) {
16485 {
16486 arg2 = wxString_in_helper(obj1);
16487 if (arg2 == NULL) SWIG_fail;
16488 temp2 = true;
16489 }
16490 }
16491 if (obj2) {
16492 {
16493 arg3 = &temp3;
16494 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16495 }
16496 }
16497 {
16498 if (!wxPyCheckForApp()) SWIG_fail;
16499 PyThreadState* __tstate = wxPyBeginAllowThreads();
16500 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16501
16502 wxPyEndAllowThreads(__tstate);
16503 if (PyErr_Occurred()) SWIG_fail;
16504 }
16505 {
16506 wxBitmap * resultptr;
16507 resultptr = new wxBitmap((wxBitmap &)(result));
16508 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16509 }
16510 {
16511 if (temp1)
16512 delete arg1;
16513 }
16514 {
16515 if (temp2)
16516 delete arg2;
16517 }
16518 return resultobj;
16519 fail:
16520 {
16521 if (temp1)
16522 delete arg1;
16523 }
16524 {
16525 if (temp2)
16526 delete arg2;
16527 }
16528 return NULL;
16529 }
16530
16531
16532 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16533 PyObject *resultobj;
16534 wxString *arg1 = 0 ;
16535 wxString const &arg2_defvalue = wxPyART_OTHER ;
16536 wxString *arg2 = (wxString *) &arg2_defvalue ;
16537 wxSize const &arg3_defvalue = wxDefaultSize ;
16538 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16539 wxIcon result;
16540 bool temp1 = false ;
16541 bool temp2 = false ;
16542 wxSize temp3 ;
16543 PyObject * obj0 = 0 ;
16544 PyObject * obj1 = 0 ;
16545 PyObject * obj2 = 0 ;
16546 char *kwnames[] = {
16547 (char *) "id",(char *) "client",(char *) "size", NULL
16548 };
16549
16550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16551 {
16552 arg1 = wxString_in_helper(obj0);
16553 if (arg1 == NULL) SWIG_fail;
16554 temp1 = true;
16555 }
16556 if (obj1) {
16557 {
16558 arg2 = wxString_in_helper(obj1);
16559 if (arg2 == NULL) SWIG_fail;
16560 temp2 = true;
16561 }
16562 }
16563 if (obj2) {
16564 {
16565 arg3 = &temp3;
16566 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16567 }
16568 }
16569 {
16570 if (!wxPyCheckForApp()) SWIG_fail;
16571 PyThreadState* __tstate = wxPyBeginAllowThreads();
16572 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16573
16574 wxPyEndAllowThreads(__tstate);
16575 if (PyErr_Occurred()) SWIG_fail;
16576 }
16577 {
16578 wxIcon * resultptr;
16579 resultptr = new wxIcon((wxIcon &)(result));
16580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16581 }
16582 {
16583 if (temp1)
16584 delete arg1;
16585 }
16586 {
16587 if (temp2)
16588 delete arg2;
16589 }
16590 return resultobj;
16591 fail:
16592 {
16593 if (temp1)
16594 delete arg1;
16595 }
16596 {
16597 if (temp2)
16598 delete arg2;
16599 }
16600 return NULL;
16601 }
16602
16603
16604 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16605 PyObject *resultobj;
16606 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16607 PyObject * obj0 = 0 ;
16608 char *kwnames[] = {
16609 (char *) "self", NULL
16610 };
16611
16612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16614 if (SWIG_arg_fail(1)) SWIG_fail;
16615 {
16616 PyThreadState* __tstate = wxPyBeginAllowThreads();
16617 wxPyArtProvider_Destroy(arg1);
16618
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 Py_INCREF(Py_None); resultobj = Py_None;
16623 return resultobj;
16624 fail:
16625 return NULL;
16626 }
16627
16628
16629 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16630 PyObject *obj;
16631 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16632 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16633 Py_INCREF(obj);
16634 return Py_BuildValue((char *)"");
16635 }
16636 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16637 PyObject *resultobj;
16638 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16639 PyObject * obj0 = 0 ;
16640 char *kwnames[] = {
16641 (char *) "self", NULL
16642 };
16643
16644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16646 if (SWIG_arg_fail(1)) SWIG_fail;
16647 {
16648 PyThreadState* __tstate = wxPyBeginAllowThreads();
16649 delete arg1;
16650
16651 wxPyEndAllowThreads(__tstate);
16652 if (PyErr_Occurred()) SWIG_fail;
16653 }
16654 Py_INCREF(Py_None); resultobj = Py_None;
16655 return resultobj;
16656 fail:
16657 return NULL;
16658 }
16659
16660
16661 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16662 PyObject *resultobj;
16663 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16664 wxConfigBase *result;
16665 PyObject * obj0 = 0 ;
16666 char *kwnames[] = {
16667 (char *) "config", NULL
16668 };
16669
16670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16672 if (SWIG_arg_fail(1)) SWIG_fail;
16673 {
16674 PyThreadState* __tstate = wxPyBeginAllowThreads();
16675 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16676
16677 wxPyEndAllowThreads(__tstate);
16678 if (PyErr_Occurred()) SWIG_fail;
16679 }
16680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16681 return resultobj;
16682 fail:
16683 return NULL;
16684 }
16685
16686
16687 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16688 PyObject *resultobj;
16689 bool arg1 = (bool) true ;
16690 wxConfigBase *result;
16691 PyObject * obj0 = 0 ;
16692 char *kwnames[] = {
16693 (char *) "createOnDemand", NULL
16694 };
16695
16696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16697 if (obj0) {
16698 {
16699 arg1 = (bool)(SWIG_As_bool(obj0));
16700 if (SWIG_arg_fail(1)) SWIG_fail;
16701 }
16702 }
16703 {
16704 PyThreadState* __tstate = wxPyBeginAllowThreads();
16705 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16706
16707 wxPyEndAllowThreads(__tstate);
16708 if (PyErr_Occurred()) SWIG_fail;
16709 }
16710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16711 return resultobj;
16712 fail:
16713 return NULL;
16714 }
16715
16716
16717 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16718 PyObject *resultobj;
16719 wxConfigBase *result;
16720 char *kwnames[] = {
16721 NULL
16722 };
16723
16724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16725 {
16726 PyThreadState* __tstate = wxPyBeginAllowThreads();
16727 result = (wxConfigBase *)wxConfigBase::Create();
16728
16729 wxPyEndAllowThreads(__tstate);
16730 if (PyErr_Occurred()) SWIG_fail;
16731 }
16732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16733 return resultobj;
16734 fail:
16735 return NULL;
16736 }
16737
16738
16739 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16740 PyObject *resultobj;
16741 char *kwnames[] = {
16742 NULL
16743 };
16744
16745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16746 {
16747 PyThreadState* __tstate = wxPyBeginAllowThreads();
16748 wxConfigBase::DontCreateOnDemand();
16749
16750 wxPyEndAllowThreads(__tstate);
16751 if (PyErr_Occurred()) SWIG_fail;
16752 }
16753 Py_INCREF(Py_None); resultobj = Py_None;
16754 return resultobj;
16755 fail:
16756 return NULL;
16757 }
16758
16759
16760 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16761 PyObject *resultobj;
16762 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16763 wxString *arg2 = 0 ;
16764 bool temp2 = false ;
16765 PyObject * obj0 = 0 ;
16766 PyObject * obj1 = 0 ;
16767 char *kwnames[] = {
16768 (char *) "self",(char *) "path", NULL
16769 };
16770
16771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16773 if (SWIG_arg_fail(1)) SWIG_fail;
16774 {
16775 arg2 = wxString_in_helper(obj1);
16776 if (arg2 == NULL) SWIG_fail;
16777 temp2 = true;
16778 }
16779 {
16780 PyThreadState* __tstate = wxPyBeginAllowThreads();
16781 (arg1)->SetPath((wxString const &)*arg2);
16782
16783 wxPyEndAllowThreads(__tstate);
16784 if (PyErr_Occurred()) SWIG_fail;
16785 }
16786 Py_INCREF(Py_None); resultobj = Py_None;
16787 {
16788 if (temp2)
16789 delete arg2;
16790 }
16791 return resultobj;
16792 fail:
16793 {
16794 if (temp2)
16795 delete arg2;
16796 }
16797 return NULL;
16798 }
16799
16800
16801 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16802 PyObject *resultobj;
16803 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16804 wxString *result;
16805 PyObject * obj0 = 0 ;
16806 char *kwnames[] = {
16807 (char *) "self", NULL
16808 };
16809
16810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16812 if (SWIG_arg_fail(1)) SWIG_fail;
16813 {
16814 PyThreadState* __tstate = wxPyBeginAllowThreads();
16815 {
16816 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16817 result = (wxString *) &_result_ref;
16818 }
16819
16820 wxPyEndAllowThreads(__tstate);
16821 if (PyErr_Occurred()) SWIG_fail;
16822 }
16823 {
16824 #if wxUSE_UNICODE
16825 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16826 #else
16827 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16828 #endif
16829 }
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj;
16838 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16839 PyObject *result;
16840 PyObject * obj0 = 0 ;
16841 char *kwnames[] = {
16842 (char *) "self", NULL
16843 };
16844
16845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16847 if (SWIG_arg_fail(1)) SWIG_fail;
16848 {
16849 PyThreadState* __tstate = wxPyBeginAllowThreads();
16850 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16851
16852 wxPyEndAllowThreads(__tstate);
16853 if (PyErr_Occurred()) SWIG_fail;
16854 }
16855 resultobj = result;
16856 return resultobj;
16857 fail:
16858 return NULL;
16859 }
16860
16861
16862 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16863 PyObject *resultobj;
16864 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16865 long arg2 ;
16866 PyObject *result;
16867 PyObject * obj0 = 0 ;
16868 PyObject * obj1 = 0 ;
16869 char *kwnames[] = {
16870 (char *) "self",(char *) "index", NULL
16871 };
16872
16873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16875 if (SWIG_arg_fail(1)) SWIG_fail;
16876 {
16877 arg2 = (long)(SWIG_As_long(obj1));
16878 if (SWIG_arg_fail(2)) SWIG_fail;
16879 }
16880 {
16881 PyThreadState* __tstate = wxPyBeginAllowThreads();
16882 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
16883
16884 wxPyEndAllowThreads(__tstate);
16885 if (PyErr_Occurred()) SWIG_fail;
16886 }
16887 resultobj = result;
16888 return resultobj;
16889 fail:
16890 return NULL;
16891 }
16892
16893
16894 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16895 PyObject *resultobj;
16896 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16897 PyObject *result;
16898 PyObject * obj0 = 0 ;
16899 char *kwnames[] = {
16900 (char *) "self", NULL
16901 };
16902
16903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
16904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16905 if (SWIG_arg_fail(1)) SWIG_fail;
16906 {
16907 PyThreadState* __tstate = wxPyBeginAllowThreads();
16908 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
16909
16910 wxPyEndAllowThreads(__tstate);
16911 if (PyErr_Occurred()) SWIG_fail;
16912 }
16913 resultobj = result;
16914 return resultobj;
16915 fail:
16916 return NULL;
16917 }
16918
16919
16920 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16921 PyObject *resultobj;
16922 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16923 long arg2 ;
16924 PyObject *result;
16925 PyObject * obj0 = 0 ;
16926 PyObject * obj1 = 0 ;
16927 char *kwnames[] = {
16928 (char *) "self",(char *) "index", NULL
16929 };
16930
16931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
16932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16933 if (SWIG_arg_fail(1)) SWIG_fail;
16934 {
16935 arg2 = (long)(SWIG_As_long(obj1));
16936 if (SWIG_arg_fail(2)) SWIG_fail;
16937 }
16938 {
16939 PyThreadState* __tstate = wxPyBeginAllowThreads();
16940 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
16941
16942 wxPyEndAllowThreads(__tstate);
16943 if (PyErr_Occurred()) SWIG_fail;
16944 }
16945 resultobj = result;
16946 return resultobj;
16947 fail:
16948 return NULL;
16949 }
16950
16951
16952 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
16953 PyObject *resultobj;
16954 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16955 bool arg2 = (bool) false ;
16956 size_t result;
16957 PyObject * obj0 = 0 ;
16958 PyObject * obj1 = 0 ;
16959 char *kwnames[] = {
16960 (char *) "self",(char *) "recursive", NULL
16961 };
16962
16963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
16964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16965 if (SWIG_arg_fail(1)) SWIG_fail;
16966 if (obj1) {
16967 {
16968 arg2 = (bool)(SWIG_As_bool(obj1));
16969 if (SWIG_arg_fail(2)) SWIG_fail;
16970 }
16971 }
16972 {
16973 PyThreadState* __tstate = wxPyBeginAllowThreads();
16974 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
16975
16976 wxPyEndAllowThreads(__tstate);
16977 if (PyErr_Occurred()) SWIG_fail;
16978 }
16979 {
16980 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16981 }
16982 return resultobj;
16983 fail:
16984 return NULL;
16985 }
16986
16987
16988 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
16989 PyObject *resultobj;
16990 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16991 bool arg2 = (bool) false ;
16992 size_t result;
16993 PyObject * obj0 = 0 ;
16994 PyObject * obj1 = 0 ;
16995 char *kwnames[] = {
16996 (char *) "self",(char *) "recursive", NULL
16997 };
16998
16999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17001 if (SWIG_arg_fail(1)) SWIG_fail;
17002 if (obj1) {
17003 {
17004 arg2 = (bool)(SWIG_As_bool(obj1));
17005 if (SWIG_arg_fail(2)) SWIG_fail;
17006 }
17007 }
17008 {
17009 PyThreadState* __tstate = wxPyBeginAllowThreads();
17010 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17011
17012 wxPyEndAllowThreads(__tstate);
17013 if (PyErr_Occurred()) SWIG_fail;
17014 }
17015 {
17016 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17017 }
17018 return resultobj;
17019 fail:
17020 return NULL;
17021 }
17022
17023
17024 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17025 PyObject *resultobj;
17026 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17027 wxString *arg2 = 0 ;
17028 bool result;
17029 bool temp2 = false ;
17030 PyObject * obj0 = 0 ;
17031 PyObject * obj1 = 0 ;
17032 char *kwnames[] = {
17033 (char *) "self",(char *) "name", NULL
17034 };
17035
17036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17038 if (SWIG_arg_fail(1)) SWIG_fail;
17039 {
17040 arg2 = wxString_in_helper(obj1);
17041 if (arg2 == NULL) SWIG_fail;
17042 temp2 = true;
17043 }
17044 {
17045 PyThreadState* __tstate = wxPyBeginAllowThreads();
17046 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17047
17048 wxPyEndAllowThreads(__tstate);
17049 if (PyErr_Occurred()) SWIG_fail;
17050 }
17051 {
17052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17053 }
17054 {
17055 if (temp2)
17056 delete arg2;
17057 }
17058 return resultobj;
17059 fail:
17060 {
17061 if (temp2)
17062 delete arg2;
17063 }
17064 return NULL;
17065 }
17066
17067
17068 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17069 PyObject *resultobj;
17070 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17071 wxString *arg2 = 0 ;
17072 bool result;
17073 bool temp2 = false ;
17074 PyObject * obj0 = 0 ;
17075 PyObject * obj1 = 0 ;
17076 char *kwnames[] = {
17077 (char *) "self",(char *) "name", NULL
17078 };
17079
17080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17082 if (SWIG_arg_fail(1)) SWIG_fail;
17083 {
17084 arg2 = wxString_in_helper(obj1);
17085 if (arg2 == NULL) SWIG_fail;
17086 temp2 = true;
17087 }
17088 {
17089 PyThreadState* __tstate = wxPyBeginAllowThreads();
17090 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17091
17092 wxPyEndAllowThreads(__tstate);
17093 if (PyErr_Occurred()) SWIG_fail;
17094 }
17095 {
17096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17097 }
17098 {
17099 if (temp2)
17100 delete arg2;
17101 }
17102 return resultobj;
17103 fail:
17104 {
17105 if (temp2)
17106 delete arg2;
17107 }
17108 return NULL;
17109 }
17110
17111
17112 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17113 PyObject *resultobj;
17114 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17115 wxString *arg2 = 0 ;
17116 bool result;
17117 bool temp2 = false ;
17118 PyObject * obj0 = 0 ;
17119 PyObject * obj1 = 0 ;
17120 char *kwnames[] = {
17121 (char *) "self",(char *) "name", NULL
17122 };
17123
17124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17126 if (SWIG_arg_fail(1)) SWIG_fail;
17127 {
17128 arg2 = wxString_in_helper(obj1);
17129 if (arg2 == NULL) SWIG_fail;
17130 temp2 = true;
17131 }
17132 {
17133 PyThreadState* __tstate = wxPyBeginAllowThreads();
17134 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17135
17136 wxPyEndAllowThreads(__tstate);
17137 if (PyErr_Occurred()) SWIG_fail;
17138 }
17139 {
17140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17141 }
17142 {
17143 if (temp2)
17144 delete arg2;
17145 }
17146 return resultobj;
17147 fail:
17148 {
17149 if (temp2)
17150 delete arg2;
17151 }
17152 return NULL;
17153 }
17154
17155
17156 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17157 PyObject *resultobj;
17158 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17159 wxString *arg2 = 0 ;
17160 wxConfigBase::EntryType result;
17161 bool temp2 = false ;
17162 PyObject * obj0 = 0 ;
17163 PyObject * obj1 = 0 ;
17164 char *kwnames[] = {
17165 (char *) "self",(char *) "name", NULL
17166 };
17167
17168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17170 if (SWIG_arg_fail(1)) SWIG_fail;
17171 {
17172 arg2 = wxString_in_helper(obj1);
17173 if (arg2 == NULL) SWIG_fail;
17174 temp2 = true;
17175 }
17176 {
17177 PyThreadState* __tstate = wxPyBeginAllowThreads();
17178 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17179
17180 wxPyEndAllowThreads(__tstate);
17181 if (PyErr_Occurred()) SWIG_fail;
17182 }
17183 resultobj = SWIG_From_int((result));
17184 {
17185 if (temp2)
17186 delete arg2;
17187 }
17188 return resultobj;
17189 fail:
17190 {
17191 if (temp2)
17192 delete arg2;
17193 }
17194 return NULL;
17195 }
17196
17197
17198 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17199 PyObject *resultobj;
17200 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17201 wxString *arg2 = 0 ;
17202 wxString const &arg3_defvalue = wxPyEmptyString ;
17203 wxString *arg3 = (wxString *) &arg3_defvalue ;
17204 wxString result;
17205 bool temp2 = false ;
17206 bool temp3 = false ;
17207 PyObject * obj0 = 0 ;
17208 PyObject * obj1 = 0 ;
17209 PyObject * obj2 = 0 ;
17210 char *kwnames[] = {
17211 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17212 };
17213
17214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17216 if (SWIG_arg_fail(1)) SWIG_fail;
17217 {
17218 arg2 = wxString_in_helper(obj1);
17219 if (arg2 == NULL) SWIG_fail;
17220 temp2 = true;
17221 }
17222 if (obj2) {
17223 {
17224 arg3 = wxString_in_helper(obj2);
17225 if (arg3 == NULL) SWIG_fail;
17226 temp3 = true;
17227 }
17228 }
17229 {
17230 PyThreadState* __tstate = wxPyBeginAllowThreads();
17231 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17232
17233 wxPyEndAllowThreads(__tstate);
17234 if (PyErr_Occurred()) SWIG_fail;
17235 }
17236 {
17237 #if wxUSE_UNICODE
17238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17239 #else
17240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17241 #endif
17242 }
17243 {
17244 if (temp2)
17245 delete arg2;
17246 }
17247 {
17248 if (temp3)
17249 delete arg3;
17250 }
17251 return resultobj;
17252 fail:
17253 {
17254 if (temp2)
17255 delete arg2;
17256 }
17257 {
17258 if (temp3)
17259 delete arg3;
17260 }
17261 return NULL;
17262 }
17263
17264
17265 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17266 PyObject *resultobj;
17267 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17268 wxString *arg2 = 0 ;
17269 long arg3 = (long) 0 ;
17270 long result;
17271 bool temp2 = false ;
17272 PyObject * obj0 = 0 ;
17273 PyObject * obj1 = 0 ;
17274 PyObject * obj2 = 0 ;
17275 char *kwnames[] = {
17276 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17277 };
17278
17279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17281 if (SWIG_arg_fail(1)) SWIG_fail;
17282 {
17283 arg2 = wxString_in_helper(obj1);
17284 if (arg2 == NULL) SWIG_fail;
17285 temp2 = true;
17286 }
17287 if (obj2) {
17288 {
17289 arg3 = (long)(SWIG_As_long(obj2));
17290 if (SWIG_arg_fail(3)) SWIG_fail;
17291 }
17292 }
17293 {
17294 PyThreadState* __tstate = wxPyBeginAllowThreads();
17295 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17296
17297 wxPyEndAllowThreads(__tstate);
17298 if (PyErr_Occurred()) SWIG_fail;
17299 }
17300 {
17301 resultobj = SWIG_From_long((long)(result));
17302 }
17303 {
17304 if (temp2)
17305 delete arg2;
17306 }
17307 return resultobj;
17308 fail:
17309 {
17310 if (temp2)
17311 delete arg2;
17312 }
17313 return NULL;
17314 }
17315
17316
17317 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17318 PyObject *resultobj;
17319 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17320 wxString *arg2 = 0 ;
17321 double arg3 = (double) 0.0 ;
17322 double result;
17323 bool temp2 = false ;
17324 PyObject * obj0 = 0 ;
17325 PyObject * obj1 = 0 ;
17326 PyObject * obj2 = 0 ;
17327 char *kwnames[] = {
17328 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17329 };
17330
17331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17333 if (SWIG_arg_fail(1)) SWIG_fail;
17334 {
17335 arg2 = wxString_in_helper(obj1);
17336 if (arg2 == NULL) SWIG_fail;
17337 temp2 = true;
17338 }
17339 if (obj2) {
17340 {
17341 arg3 = (double)(SWIG_As_double(obj2));
17342 if (SWIG_arg_fail(3)) SWIG_fail;
17343 }
17344 }
17345 {
17346 PyThreadState* __tstate = wxPyBeginAllowThreads();
17347 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17348
17349 wxPyEndAllowThreads(__tstate);
17350 if (PyErr_Occurred()) SWIG_fail;
17351 }
17352 {
17353 resultobj = SWIG_From_double((double)(result));
17354 }
17355 {
17356 if (temp2)
17357 delete arg2;
17358 }
17359 return resultobj;
17360 fail:
17361 {
17362 if (temp2)
17363 delete arg2;
17364 }
17365 return NULL;
17366 }
17367
17368
17369 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17370 PyObject *resultobj;
17371 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17372 wxString *arg2 = 0 ;
17373 bool arg3 = (bool) false ;
17374 bool result;
17375 bool temp2 = false ;
17376 PyObject * obj0 = 0 ;
17377 PyObject * obj1 = 0 ;
17378 PyObject * obj2 = 0 ;
17379 char *kwnames[] = {
17380 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17381 };
17382
17383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17385 if (SWIG_arg_fail(1)) SWIG_fail;
17386 {
17387 arg2 = wxString_in_helper(obj1);
17388 if (arg2 == NULL) SWIG_fail;
17389 temp2 = true;
17390 }
17391 if (obj2) {
17392 {
17393 arg3 = (bool)(SWIG_As_bool(obj2));
17394 if (SWIG_arg_fail(3)) SWIG_fail;
17395 }
17396 }
17397 {
17398 PyThreadState* __tstate = wxPyBeginAllowThreads();
17399 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17400
17401 wxPyEndAllowThreads(__tstate);
17402 if (PyErr_Occurred()) SWIG_fail;
17403 }
17404 {
17405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17406 }
17407 {
17408 if (temp2)
17409 delete arg2;
17410 }
17411 return resultobj;
17412 fail:
17413 {
17414 if (temp2)
17415 delete arg2;
17416 }
17417 return NULL;
17418 }
17419
17420
17421 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17422 PyObject *resultobj;
17423 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17424 wxString *arg2 = 0 ;
17425 wxString *arg3 = 0 ;
17426 bool result;
17427 bool temp2 = false ;
17428 bool temp3 = false ;
17429 PyObject * obj0 = 0 ;
17430 PyObject * obj1 = 0 ;
17431 PyObject * obj2 = 0 ;
17432 char *kwnames[] = {
17433 (char *) "self",(char *) "key",(char *) "value", NULL
17434 };
17435
17436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17438 if (SWIG_arg_fail(1)) SWIG_fail;
17439 {
17440 arg2 = wxString_in_helper(obj1);
17441 if (arg2 == NULL) SWIG_fail;
17442 temp2 = true;
17443 }
17444 {
17445 arg3 = wxString_in_helper(obj2);
17446 if (arg3 == NULL) SWIG_fail;
17447 temp3 = true;
17448 }
17449 {
17450 PyThreadState* __tstate = wxPyBeginAllowThreads();
17451 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17452
17453 wxPyEndAllowThreads(__tstate);
17454 if (PyErr_Occurred()) SWIG_fail;
17455 }
17456 {
17457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17458 }
17459 {
17460 if (temp2)
17461 delete arg2;
17462 }
17463 {
17464 if (temp3)
17465 delete arg3;
17466 }
17467 return resultobj;
17468 fail:
17469 {
17470 if (temp2)
17471 delete arg2;
17472 }
17473 {
17474 if (temp3)
17475 delete arg3;
17476 }
17477 return NULL;
17478 }
17479
17480
17481 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17482 PyObject *resultobj;
17483 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17484 wxString *arg2 = 0 ;
17485 long arg3 ;
17486 bool result;
17487 bool temp2 = false ;
17488 PyObject * obj0 = 0 ;
17489 PyObject * obj1 = 0 ;
17490 PyObject * obj2 = 0 ;
17491 char *kwnames[] = {
17492 (char *) "self",(char *) "key",(char *) "value", NULL
17493 };
17494
17495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17497 if (SWIG_arg_fail(1)) SWIG_fail;
17498 {
17499 arg2 = wxString_in_helper(obj1);
17500 if (arg2 == NULL) SWIG_fail;
17501 temp2 = true;
17502 }
17503 {
17504 arg3 = (long)(SWIG_As_long(obj2));
17505 if (SWIG_arg_fail(3)) SWIG_fail;
17506 }
17507 {
17508 PyThreadState* __tstate = wxPyBeginAllowThreads();
17509 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17510
17511 wxPyEndAllowThreads(__tstate);
17512 if (PyErr_Occurred()) SWIG_fail;
17513 }
17514 {
17515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17516 }
17517 {
17518 if (temp2)
17519 delete arg2;
17520 }
17521 return resultobj;
17522 fail:
17523 {
17524 if (temp2)
17525 delete arg2;
17526 }
17527 return NULL;
17528 }
17529
17530
17531 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17532 PyObject *resultobj;
17533 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17534 wxString *arg2 = 0 ;
17535 double arg3 ;
17536 bool result;
17537 bool temp2 = false ;
17538 PyObject * obj0 = 0 ;
17539 PyObject * obj1 = 0 ;
17540 PyObject * obj2 = 0 ;
17541 char *kwnames[] = {
17542 (char *) "self",(char *) "key",(char *) "value", NULL
17543 };
17544
17545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17547 if (SWIG_arg_fail(1)) SWIG_fail;
17548 {
17549 arg2 = wxString_in_helper(obj1);
17550 if (arg2 == NULL) SWIG_fail;
17551 temp2 = true;
17552 }
17553 {
17554 arg3 = (double)(SWIG_As_double(obj2));
17555 if (SWIG_arg_fail(3)) SWIG_fail;
17556 }
17557 {
17558 PyThreadState* __tstate = wxPyBeginAllowThreads();
17559 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17560
17561 wxPyEndAllowThreads(__tstate);
17562 if (PyErr_Occurred()) SWIG_fail;
17563 }
17564 {
17565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17566 }
17567 {
17568 if (temp2)
17569 delete arg2;
17570 }
17571 return resultobj;
17572 fail:
17573 {
17574 if (temp2)
17575 delete arg2;
17576 }
17577 return NULL;
17578 }
17579
17580
17581 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17582 PyObject *resultobj;
17583 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17584 wxString *arg2 = 0 ;
17585 bool arg3 ;
17586 bool result;
17587 bool temp2 = false ;
17588 PyObject * obj0 = 0 ;
17589 PyObject * obj1 = 0 ;
17590 PyObject * obj2 = 0 ;
17591 char *kwnames[] = {
17592 (char *) "self",(char *) "key",(char *) "value", NULL
17593 };
17594
17595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17597 if (SWIG_arg_fail(1)) SWIG_fail;
17598 {
17599 arg2 = wxString_in_helper(obj1);
17600 if (arg2 == NULL) SWIG_fail;
17601 temp2 = true;
17602 }
17603 {
17604 arg3 = (bool)(SWIG_As_bool(obj2));
17605 if (SWIG_arg_fail(3)) SWIG_fail;
17606 }
17607 {
17608 PyThreadState* __tstate = wxPyBeginAllowThreads();
17609 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17610
17611 wxPyEndAllowThreads(__tstate);
17612 if (PyErr_Occurred()) SWIG_fail;
17613 }
17614 {
17615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17616 }
17617 {
17618 if (temp2)
17619 delete arg2;
17620 }
17621 return resultobj;
17622 fail:
17623 {
17624 if (temp2)
17625 delete arg2;
17626 }
17627 return NULL;
17628 }
17629
17630
17631 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17632 PyObject *resultobj;
17633 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17634 bool arg2 = (bool) false ;
17635 bool result;
17636 PyObject * obj0 = 0 ;
17637 PyObject * obj1 = 0 ;
17638 char *kwnames[] = {
17639 (char *) "self",(char *) "currentOnly", NULL
17640 };
17641
17642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17644 if (SWIG_arg_fail(1)) SWIG_fail;
17645 if (obj1) {
17646 {
17647 arg2 = (bool)(SWIG_As_bool(obj1));
17648 if (SWIG_arg_fail(2)) SWIG_fail;
17649 }
17650 }
17651 {
17652 PyThreadState* __tstate = wxPyBeginAllowThreads();
17653 result = (bool)(arg1)->Flush(arg2);
17654
17655 wxPyEndAllowThreads(__tstate);
17656 if (PyErr_Occurred()) SWIG_fail;
17657 }
17658 {
17659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17660 }
17661 return resultobj;
17662 fail:
17663 return NULL;
17664 }
17665
17666
17667 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17668 PyObject *resultobj;
17669 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17670 wxString *arg2 = 0 ;
17671 wxString *arg3 = 0 ;
17672 bool result;
17673 bool temp2 = false ;
17674 bool temp3 = false ;
17675 PyObject * obj0 = 0 ;
17676 PyObject * obj1 = 0 ;
17677 PyObject * obj2 = 0 ;
17678 char *kwnames[] = {
17679 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17680 };
17681
17682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17684 if (SWIG_arg_fail(1)) SWIG_fail;
17685 {
17686 arg2 = wxString_in_helper(obj1);
17687 if (arg2 == NULL) SWIG_fail;
17688 temp2 = true;
17689 }
17690 {
17691 arg3 = wxString_in_helper(obj2);
17692 if (arg3 == NULL) SWIG_fail;
17693 temp3 = true;
17694 }
17695 {
17696 PyThreadState* __tstate = wxPyBeginAllowThreads();
17697 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17698
17699 wxPyEndAllowThreads(__tstate);
17700 if (PyErr_Occurred()) SWIG_fail;
17701 }
17702 {
17703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17704 }
17705 {
17706 if (temp2)
17707 delete arg2;
17708 }
17709 {
17710 if (temp3)
17711 delete arg3;
17712 }
17713 return resultobj;
17714 fail:
17715 {
17716 if (temp2)
17717 delete arg2;
17718 }
17719 {
17720 if (temp3)
17721 delete arg3;
17722 }
17723 return NULL;
17724 }
17725
17726
17727 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17728 PyObject *resultobj;
17729 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17730 wxString *arg2 = 0 ;
17731 wxString *arg3 = 0 ;
17732 bool result;
17733 bool temp2 = false ;
17734 bool temp3 = false ;
17735 PyObject * obj0 = 0 ;
17736 PyObject * obj1 = 0 ;
17737 PyObject * obj2 = 0 ;
17738 char *kwnames[] = {
17739 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17740 };
17741
17742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17744 if (SWIG_arg_fail(1)) SWIG_fail;
17745 {
17746 arg2 = wxString_in_helper(obj1);
17747 if (arg2 == NULL) SWIG_fail;
17748 temp2 = true;
17749 }
17750 {
17751 arg3 = wxString_in_helper(obj2);
17752 if (arg3 == NULL) SWIG_fail;
17753 temp3 = true;
17754 }
17755 {
17756 PyThreadState* __tstate = wxPyBeginAllowThreads();
17757 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17758
17759 wxPyEndAllowThreads(__tstate);
17760 if (PyErr_Occurred()) SWIG_fail;
17761 }
17762 {
17763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17764 }
17765 {
17766 if (temp2)
17767 delete arg2;
17768 }
17769 {
17770 if (temp3)
17771 delete arg3;
17772 }
17773 return resultobj;
17774 fail:
17775 {
17776 if (temp2)
17777 delete arg2;
17778 }
17779 {
17780 if (temp3)
17781 delete arg3;
17782 }
17783 return NULL;
17784 }
17785
17786
17787 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17788 PyObject *resultobj;
17789 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17790 wxString *arg2 = 0 ;
17791 bool arg3 = (bool) true ;
17792 bool result;
17793 bool temp2 = false ;
17794 PyObject * obj0 = 0 ;
17795 PyObject * obj1 = 0 ;
17796 PyObject * obj2 = 0 ;
17797 char *kwnames[] = {
17798 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17799 };
17800
17801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17803 if (SWIG_arg_fail(1)) SWIG_fail;
17804 {
17805 arg2 = wxString_in_helper(obj1);
17806 if (arg2 == NULL) SWIG_fail;
17807 temp2 = true;
17808 }
17809 if (obj2) {
17810 {
17811 arg3 = (bool)(SWIG_As_bool(obj2));
17812 if (SWIG_arg_fail(3)) SWIG_fail;
17813 }
17814 }
17815 {
17816 PyThreadState* __tstate = wxPyBeginAllowThreads();
17817 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17818
17819 wxPyEndAllowThreads(__tstate);
17820 if (PyErr_Occurred()) SWIG_fail;
17821 }
17822 {
17823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17824 }
17825 {
17826 if (temp2)
17827 delete arg2;
17828 }
17829 return resultobj;
17830 fail:
17831 {
17832 if (temp2)
17833 delete arg2;
17834 }
17835 return NULL;
17836 }
17837
17838
17839 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17840 PyObject *resultobj;
17841 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17842 wxString *arg2 = 0 ;
17843 bool result;
17844 bool temp2 = false ;
17845 PyObject * obj0 = 0 ;
17846 PyObject * obj1 = 0 ;
17847 char *kwnames[] = {
17848 (char *) "self",(char *) "key", NULL
17849 };
17850
17851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17853 if (SWIG_arg_fail(1)) SWIG_fail;
17854 {
17855 arg2 = wxString_in_helper(obj1);
17856 if (arg2 == NULL) SWIG_fail;
17857 temp2 = true;
17858 }
17859 {
17860 PyThreadState* __tstate = wxPyBeginAllowThreads();
17861 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17862
17863 wxPyEndAllowThreads(__tstate);
17864 if (PyErr_Occurred()) SWIG_fail;
17865 }
17866 {
17867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17868 }
17869 {
17870 if (temp2)
17871 delete arg2;
17872 }
17873 return resultobj;
17874 fail:
17875 {
17876 if (temp2)
17877 delete arg2;
17878 }
17879 return NULL;
17880 }
17881
17882
17883 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
17884 PyObject *resultobj;
17885 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17886 bool result;
17887 PyObject * obj0 = 0 ;
17888 char *kwnames[] = {
17889 (char *) "self", NULL
17890 };
17891
17892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
17893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17894 if (SWIG_arg_fail(1)) SWIG_fail;
17895 {
17896 PyThreadState* __tstate = wxPyBeginAllowThreads();
17897 result = (bool)(arg1)->DeleteAll();
17898
17899 wxPyEndAllowThreads(__tstate);
17900 if (PyErr_Occurred()) SWIG_fail;
17901 }
17902 {
17903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17904 }
17905 return resultobj;
17906 fail:
17907 return NULL;
17908 }
17909
17910
17911 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17912 PyObject *resultobj;
17913 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17914 bool arg2 = (bool) true ;
17915 PyObject * obj0 = 0 ;
17916 PyObject * obj1 = 0 ;
17917 char *kwnames[] = {
17918 (char *) "self",(char *) "doIt", NULL
17919 };
17920
17921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17923 if (SWIG_arg_fail(1)) SWIG_fail;
17924 if (obj1) {
17925 {
17926 arg2 = (bool)(SWIG_As_bool(obj1));
17927 if (SWIG_arg_fail(2)) SWIG_fail;
17928 }
17929 }
17930 {
17931 PyThreadState* __tstate = wxPyBeginAllowThreads();
17932 (arg1)->SetExpandEnvVars(arg2);
17933
17934 wxPyEndAllowThreads(__tstate);
17935 if (PyErr_Occurred()) SWIG_fail;
17936 }
17937 Py_INCREF(Py_None); resultobj = Py_None;
17938 return resultobj;
17939 fail:
17940 return NULL;
17941 }
17942
17943
17944 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17945 PyObject *resultobj;
17946 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17947 bool result;
17948 PyObject * obj0 = 0 ;
17949 char *kwnames[] = {
17950 (char *) "self", NULL
17951 };
17952
17953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
17954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17955 if (SWIG_arg_fail(1)) SWIG_fail;
17956 {
17957 PyThreadState* __tstate = wxPyBeginAllowThreads();
17958 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
17959
17960 wxPyEndAllowThreads(__tstate);
17961 if (PyErr_Occurred()) SWIG_fail;
17962 }
17963 {
17964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17965 }
17966 return resultobj;
17967 fail:
17968 return NULL;
17969 }
17970
17971
17972 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17973 PyObject *resultobj;
17974 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17975 bool arg2 = (bool) true ;
17976 PyObject * obj0 = 0 ;
17977 PyObject * obj1 = 0 ;
17978 char *kwnames[] = {
17979 (char *) "self",(char *) "doIt", NULL
17980 };
17981
17982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
17983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17984 if (SWIG_arg_fail(1)) SWIG_fail;
17985 if (obj1) {
17986 {
17987 arg2 = (bool)(SWIG_As_bool(obj1));
17988 if (SWIG_arg_fail(2)) SWIG_fail;
17989 }
17990 }
17991 {
17992 PyThreadState* __tstate = wxPyBeginAllowThreads();
17993 (arg1)->SetRecordDefaults(arg2);
17994
17995 wxPyEndAllowThreads(__tstate);
17996 if (PyErr_Occurred()) SWIG_fail;
17997 }
17998 Py_INCREF(Py_None); resultobj = Py_None;
17999 return resultobj;
18000 fail:
18001 return NULL;
18002 }
18003
18004
18005 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18006 PyObject *resultobj;
18007 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18008 bool result;
18009 PyObject * obj0 = 0 ;
18010 char *kwnames[] = {
18011 (char *) "self", NULL
18012 };
18013
18014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18016 if (SWIG_arg_fail(1)) SWIG_fail;
18017 {
18018 PyThreadState* __tstate = wxPyBeginAllowThreads();
18019 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18020
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 {
18025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18026 }
18027 return resultobj;
18028 fail:
18029 return NULL;
18030 }
18031
18032
18033 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18034 PyObject *resultobj;
18035 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18036 wxString *arg2 = 0 ;
18037 wxString result;
18038 bool temp2 = false ;
18039 PyObject * obj0 = 0 ;
18040 PyObject * obj1 = 0 ;
18041 char *kwnames[] = {
18042 (char *) "self",(char *) "str", NULL
18043 };
18044
18045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18047 if (SWIG_arg_fail(1)) SWIG_fail;
18048 {
18049 arg2 = wxString_in_helper(obj1);
18050 if (arg2 == NULL) SWIG_fail;
18051 temp2 = true;
18052 }
18053 {
18054 PyThreadState* __tstate = wxPyBeginAllowThreads();
18055 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18056
18057 wxPyEndAllowThreads(__tstate);
18058 if (PyErr_Occurred()) SWIG_fail;
18059 }
18060 {
18061 #if wxUSE_UNICODE
18062 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18063 #else
18064 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18065 #endif
18066 }
18067 {
18068 if (temp2)
18069 delete arg2;
18070 }
18071 return resultobj;
18072 fail:
18073 {
18074 if (temp2)
18075 delete arg2;
18076 }
18077 return NULL;
18078 }
18079
18080
18081 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18082 PyObject *resultobj;
18083 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18084 wxString result;
18085 PyObject * obj0 = 0 ;
18086 char *kwnames[] = {
18087 (char *) "self", NULL
18088 };
18089
18090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18092 if (SWIG_arg_fail(1)) SWIG_fail;
18093 {
18094 PyThreadState* __tstate = wxPyBeginAllowThreads();
18095 result = ((wxConfigBase const *)arg1)->GetAppName();
18096
18097 wxPyEndAllowThreads(__tstate);
18098 if (PyErr_Occurred()) SWIG_fail;
18099 }
18100 {
18101 #if wxUSE_UNICODE
18102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18103 #else
18104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18105 #endif
18106 }
18107 return resultobj;
18108 fail:
18109 return NULL;
18110 }
18111
18112
18113 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18114 PyObject *resultobj;
18115 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18116 wxString result;
18117 PyObject * obj0 = 0 ;
18118 char *kwnames[] = {
18119 (char *) "self", NULL
18120 };
18121
18122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18124 if (SWIG_arg_fail(1)) SWIG_fail;
18125 {
18126 PyThreadState* __tstate = wxPyBeginAllowThreads();
18127 result = ((wxConfigBase const *)arg1)->GetVendorName();
18128
18129 wxPyEndAllowThreads(__tstate);
18130 if (PyErr_Occurred()) SWIG_fail;
18131 }
18132 {
18133 #if wxUSE_UNICODE
18134 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18135 #else
18136 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18137 #endif
18138 }
18139 return resultobj;
18140 fail:
18141 return NULL;
18142 }
18143
18144
18145 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18146 PyObject *resultobj;
18147 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18148 wxString *arg2 = 0 ;
18149 bool temp2 = false ;
18150 PyObject * obj0 = 0 ;
18151 PyObject * obj1 = 0 ;
18152 char *kwnames[] = {
18153 (char *) "self",(char *) "appName", NULL
18154 };
18155
18156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18158 if (SWIG_arg_fail(1)) SWIG_fail;
18159 {
18160 arg2 = wxString_in_helper(obj1);
18161 if (arg2 == NULL) SWIG_fail;
18162 temp2 = true;
18163 }
18164 {
18165 PyThreadState* __tstate = wxPyBeginAllowThreads();
18166 (arg1)->SetAppName((wxString const &)*arg2);
18167
18168 wxPyEndAllowThreads(__tstate);
18169 if (PyErr_Occurred()) SWIG_fail;
18170 }
18171 Py_INCREF(Py_None); resultobj = Py_None;
18172 {
18173 if (temp2)
18174 delete arg2;
18175 }
18176 return resultobj;
18177 fail:
18178 {
18179 if (temp2)
18180 delete arg2;
18181 }
18182 return NULL;
18183 }
18184
18185
18186 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18187 PyObject *resultobj;
18188 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18189 wxString *arg2 = 0 ;
18190 bool temp2 = false ;
18191 PyObject * obj0 = 0 ;
18192 PyObject * obj1 = 0 ;
18193 char *kwnames[] = {
18194 (char *) "self",(char *) "vendorName", NULL
18195 };
18196
18197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18199 if (SWIG_arg_fail(1)) SWIG_fail;
18200 {
18201 arg2 = wxString_in_helper(obj1);
18202 if (arg2 == NULL) SWIG_fail;
18203 temp2 = true;
18204 }
18205 {
18206 PyThreadState* __tstate = wxPyBeginAllowThreads();
18207 (arg1)->SetVendorName((wxString const &)*arg2);
18208
18209 wxPyEndAllowThreads(__tstate);
18210 if (PyErr_Occurred()) SWIG_fail;
18211 }
18212 Py_INCREF(Py_None); resultobj = Py_None;
18213 {
18214 if (temp2)
18215 delete arg2;
18216 }
18217 return resultobj;
18218 fail:
18219 {
18220 if (temp2)
18221 delete arg2;
18222 }
18223 return NULL;
18224 }
18225
18226
18227 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18228 PyObject *resultobj;
18229 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18230 long arg2 ;
18231 PyObject * obj0 = 0 ;
18232 PyObject * obj1 = 0 ;
18233 char *kwnames[] = {
18234 (char *) "self",(char *) "style", NULL
18235 };
18236
18237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18239 if (SWIG_arg_fail(1)) SWIG_fail;
18240 {
18241 arg2 = (long)(SWIG_As_long(obj1));
18242 if (SWIG_arg_fail(2)) SWIG_fail;
18243 }
18244 {
18245 PyThreadState* __tstate = wxPyBeginAllowThreads();
18246 (arg1)->SetStyle(arg2);
18247
18248 wxPyEndAllowThreads(__tstate);
18249 if (PyErr_Occurred()) SWIG_fail;
18250 }
18251 Py_INCREF(Py_None); resultobj = Py_None;
18252 return resultobj;
18253 fail:
18254 return NULL;
18255 }
18256
18257
18258 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18259 PyObject *resultobj;
18260 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18261 long result;
18262 PyObject * obj0 = 0 ;
18263 char *kwnames[] = {
18264 (char *) "self", NULL
18265 };
18266
18267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18269 if (SWIG_arg_fail(1)) SWIG_fail;
18270 {
18271 PyThreadState* __tstate = wxPyBeginAllowThreads();
18272 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18273
18274 wxPyEndAllowThreads(__tstate);
18275 if (PyErr_Occurred()) SWIG_fail;
18276 }
18277 {
18278 resultobj = SWIG_From_long((long)(result));
18279 }
18280 return resultobj;
18281 fail:
18282 return NULL;
18283 }
18284
18285
18286 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18287 PyObject *obj;
18288 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18289 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18290 Py_INCREF(obj);
18291 return Py_BuildValue((char *)"");
18292 }
18293 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18294 PyObject *resultobj;
18295 wxString const &arg1_defvalue = wxPyEmptyString ;
18296 wxString *arg1 = (wxString *) &arg1_defvalue ;
18297 wxString const &arg2_defvalue = wxPyEmptyString ;
18298 wxString *arg2 = (wxString *) &arg2_defvalue ;
18299 wxString const &arg3_defvalue = wxPyEmptyString ;
18300 wxString *arg3 = (wxString *) &arg3_defvalue ;
18301 wxString const &arg4_defvalue = wxPyEmptyString ;
18302 wxString *arg4 = (wxString *) &arg4_defvalue ;
18303 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18304 wxConfig *result;
18305 bool temp1 = false ;
18306 bool temp2 = false ;
18307 bool temp3 = false ;
18308 bool temp4 = false ;
18309 PyObject * obj0 = 0 ;
18310 PyObject * obj1 = 0 ;
18311 PyObject * obj2 = 0 ;
18312 PyObject * obj3 = 0 ;
18313 PyObject * obj4 = 0 ;
18314 char *kwnames[] = {
18315 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18316 };
18317
18318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18319 if (obj0) {
18320 {
18321 arg1 = wxString_in_helper(obj0);
18322 if (arg1 == NULL) SWIG_fail;
18323 temp1 = true;
18324 }
18325 }
18326 if (obj1) {
18327 {
18328 arg2 = wxString_in_helper(obj1);
18329 if (arg2 == NULL) SWIG_fail;
18330 temp2 = true;
18331 }
18332 }
18333 if (obj2) {
18334 {
18335 arg3 = wxString_in_helper(obj2);
18336 if (arg3 == NULL) SWIG_fail;
18337 temp3 = true;
18338 }
18339 }
18340 if (obj3) {
18341 {
18342 arg4 = wxString_in_helper(obj3);
18343 if (arg4 == NULL) SWIG_fail;
18344 temp4 = true;
18345 }
18346 }
18347 if (obj4) {
18348 {
18349 arg5 = (long)(SWIG_As_long(obj4));
18350 if (SWIG_arg_fail(5)) SWIG_fail;
18351 }
18352 }
18353 {
18354 PyThreadState* __tstate = wxPyBeginAllowThreads();
18355 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18356
18357 wxPyEndAllowThreads(__tstate);
18358 if (PyErr_Occurred()) SWIG_fail;
18359 }
18360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18361 {
18362 if (temp1)
18363 delete arg1;
18364 }
18365 {
18366 if (temp2)
18367 delete arg2;
18368 }
18369 {
18370 if (temp3)
18371 delete arg3;
18372 }
18373 {
18374 if (temp4)
18375 delete arg4;
18376 }
18377 return resultobj;
18378 fail:
18379 {
18380 if (temp1)
18381 delete arg1;
18382 }
18383 {
18384 if (temp2)
18385 delete arg2;
18386 }
18387 {
18388 if (temp3)
18389 delete arg3;
18390 }
18391 {
18392 if (temp4)
18393 delete arg4;
18394 }
18395 return NULL;
18396 }
18397
18398
18399 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18400 PyObject *resultobj;
18401 wxConfig *arg1 = (wxConfig *) 0 ;
18402 PyObject * obj0 = 0 ;
18403 char *kwnames[] = {
18404 (char *) "self", NULL
18405 };
18406
18407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18409 if (SWIG_arg_fail(1)) SWIG_fail;
18410 {
18411 PyThreadState* __tstate = wxPyBeginAllowThreads();
18412 delete arg1;
18413
18414 wxPyEndAllowThreads(__tstate);
18415 if (PyErr_Occurred()) SWIG_fail;
18416 }
18417 Py_INCREF(Py_None); resultobj = Py_None;
18418 return resultobj;
18419 fail:
18420 return NULL;
18421 }
18422
18423
18424 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18425 PyObject *obj;
18426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18427 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18428 Py_INCREF(obj);
18429 return Py_BuildValue((char *)"");
18430 }
18431 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18432 PyObject *resultobj;
18433 wxString const &arg1_defvalue = wxPyEmptyString ;
18434 wxString *arg1 = (wxString *) &arg1_defvalue ;
18435 wxString const &arg2_defvalue = wxPyEmptyString ;
18436 wxString *arg2 = (wxString *) &arg2_defvalue ;
18437 wxString const &arg3_defvalue = wxPyEmptyString ;
18438 wxString *arg3 = (wxString *) &arg3_defvalue ;
18439 wxString const &arg4_defvalue = wxPyEmptyString ;
18440 wxString *arg4 = (wxString *) &arg4_defvalue ;
18441 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18442 wxFileConfig *result;
18443 bool temp1 = false ;
18444 bool temp2 = false ;
18445 bool temp3 = false ;
18446 bool temp4 = false ;
18447 PyObject * obj0 = 0 ;
18448 PyObject * obj1 = 0 ;
18449 PyObject * obj2 = 0 ;
18450 PyObject * obj3 = 0 ;
18451 PyObject * obj4 = 0 ;
18452 char *kwnames[] = {
18453 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18454 };
18455
18456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18457 if (obj0) {
18458 {
18459 arg1 = wxString_in_helper(obj0);
18460 if (arg1 == NULL) SWIG_fail;
18461 temp1 = true;
18462 }
18463 }
18464 if (obj1) {
18465 {
18466 arg2 = wxString_in_helper(obj1);
18467 if (arg2 == NULL) SWIG_fail;
18468 temp2 = true;
18469 }
18470 }
18471 if (obj2) {
18472 {
18473 arg3 = wxString_in_helper(obj2);
18474 if (arg3 == NULL) SWIG_fail;
18475 temp3 = true;
18476 }
18477 }
18478 if (obj3) {
18479 {
18480 arg4 = wxString_in_helper(obj3);
18481 if (arg4 == NULL) SWIG_fail;
18482 temp4 = true;
18483 }
18484 }
18485 if (obj4) {
18486 {
18487 arg5 = (long)(SWIG_As_long(obj4));
18488 if (SWIG_arg_fail(5)) SWIG_fail;
18489 }
18490 }
18491 {
18492 PyThreadState* __tstate = wxPyBeginAllowThreads();
18493 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18494
18495 wxPyEndAllowThreads(__tstate);
18496 if (PyErr_Occurred()) SWIG_fail;
18497 }
18498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18499 {
18500 if (temp1)
18501 delete arg1;
18502 }
18503 {
18504 if (temp2)
18505 delete arg2;
18506 }
18507 {
18508 if (temp3)
18509 delete arg3;
18510 }
18511 {
18512 if (temp4)
18513 delete arg4;
18514 }
18515 return resultobj;
18516 fail:
18517 {
18518 if (temp1)
18519 delete arg1;
18520 }
18521 {
18522 if (temp2)
18523 delete arg2;
18524 }
18525 {
18526 if (temp3)
18527 delete arg3;
18528 }
18529 {
18530 if (temp4)
18531 delete arg4;
18532 }
18533 return NULL;
18534 }
18535
18536
18537 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18538 PyObject *resultobj;
18539 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18540 PyObject * obj0 = 0 ;
18541 char *kwnames[] = {
18542 (char *) "self", NULL
18543 };
18544
18545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18547 if (SWIG_arg_fail(1)) SWIG_fail;
18548 {
18549 PyThreadState* __tstate = wxPyBeginAllowThreads();
18550 delete arg1;
18551
18552 wxPyEndAllowThreads(__tstate);
18553 if (PyErr_Occurred()) SWIG_fail;
18554 }
18555 Py_INCREF(Py_None); resultobj = Py_None;
18556 return resultobj;
18557 fail:
18558 return NULL;
18559 }
18560
18561
18562 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18563 PyObject *obj;
18564 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18565 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18566 Py_INCREF(obj);
18567 return Py_BuildValue((char *)"");
18568 }
18569 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18570 PyObject *resultobj;
18571 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18572 wxString *arg2 = 0 ;
18573 wxConfigPathChanger *result;
18574 bool temp2 = false ;
18575 PyObject * obj0 = 0 ;
18576 PyObject * obj1 = 0 ;
18577 char *kwnames[] = {
18578 (char *) "config",(char *) "entry", NULL
18579 };
18580
18581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18583 if (SWIG_arg_fail(1)) SWIG_fail;
18584 {
18585 arg2 = wxString_in_helper(obj1);
18586 if (arg2 == NULL) SWIG_fail;
18587 temp2 = true;
18588 }
18589 {
18590 PyThreadState* __tstate = wxPyBeginAllowThreads();
18591 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18592
18593 wxPyEndAllowThreads(__tstate);
18594 if (PyErr_Occurred()) SWIG_fail;
18595 }
18596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18597 {
18598 if (temp2)
18599 delete arg2;
18600 }
18601 return resultobj;
18602 fail:
18603 {
18604 if (temp2)
18605 delete arg2;
18606 }
18607 return NULL;
18608 }
18609
18610
18611 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18612 PyObject *resultobj;
18613 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18614 PyObject * obj0 = 0 ;
18615 char *kwnames[] = {
18616 (char *) "self", NULL
18617 };
18618
18619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18621 if (SWIG_arg_fail(1)) SWIG_fail;
18622 {
18623 PyThreadState* __tstate = wxPyBeginAllowThreads();
18624 delete arg1;
18625
18626 wxPyEndAllowThreads(__tstate);
18627 if (PyErr_Occurred()) SWIG_fail;
18628 }
18629 Py_INCREF(Py_None); resultobj = Py_None;
18630 return resultobj;
18631 fail:
18632 return NULL;
18633 }
18634
18635
18636 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18637 PyObject *resultobj;
18638 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18639 wxString *result;
18640 PyObject * obj0 = 0 ;
18641 char *kwnames[] = {
18642 (char *) "self", NULL
18643 };
18644
18645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18647 if (SWIG_arg_fail(1)) SWIG_fail;
18648 {
18649 PyThreadState* __tstate = wxPyBeginAllowThreads();
18650 {
18651 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18652 result = (wxString *) &_result_ref;
18653 }
18654
18655 wxPyEndAllowThreads(__tstate);
18656 if (PyErr_Occurred()) SWIG_fail;
18657 }
18658 {
18659 #if wxUSE_UNICODE
18660 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18661 #else
18662 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18663 #endif
18664 }
18665 return resultobj;
18666 fail:
18667 return NULL;
18668 }
18669
18670
18671 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18672 PyObject *obj;
18673 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18674 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18675 Py_INCREF(obj);
18676 return Py_BuildValue((char *)"");
18677 }
18678 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18679 PyObject *resultobj;
18680 wxString *arg1 = 0 ;
18681 wxString result;
18682 bool temp1 = false ;
18683 PyObject * obj0 = 0 ;
18684 char *kwnames[] = {
18685 (char *) "sz", NULL
18686 };
18687
18688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18689 {
18690 arg1 = wxString_in_helper(obj0);
18691 if (arg1 == NULL) SWIG_fail;
18692 temp1 = true;
18693 }
18694 {
18695 PyThreadState* __tstate = wxPyBeginAllowThreads();
18696 result = wxExpandEnvVars((wxString const &)*arg1);
18697
18698 wxPyEndAllowThreads(__tstate);
18699 if (PyErr_Occurred()) SWIG_fail;
18700 }
18701 {
18702 #if wxUSE_UNICODE
18703 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18704 #else
18705 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18706 #endif
18707 }
18708 {
18709 if (temp1)
18710 delete arg1;
18711 }
18712 return resultobj;
18713 fail:
18714 {
18715 if (temp1)
18716 delete arg1;
18717 }
18718 return NULL;
18719 }
18720
18721
18722 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18723 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18724 return 1;
18725 }
18726
18727
18728 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18729 PyObject *pyobj;
18730
18731 {
18732 #if wxUSE_UNICODE
18733 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18734 #else
18735 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18736 #endif
18737 }
18738 return pyobj;
18739 }
18740
18741
18742 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18743 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18744 return 1;
18745 }
18746
18747
18748 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18749 PyObject *pyobj;
18750
18751 {
18752 #if wxUSE_UNICODE
18753 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18754 #else
18755 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18756 #endif
18757 }
18758 return pyobj;
18759 }
18760
18761
18762 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18763 PyObject *resultobj;
18764 wxDateTime::Country arg1 ;
18765 PyObject * obj0 = 0 ;
18766 char *kwnames[] = {
18767 (char *) "country", NULL
18768 };
18769
18770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18771 {
18772 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18773 if (SWIG_arg_fail(1)) SWIG_fail;
18774 }
18775 {
18776 PyThreadState* __tstate = wxPyBeginAllowThreads();
18777 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18778
18779 wxPyEndAllowThreads(__tstate);
18780 if (PyErr_Occurred()) SWIG_fail;
18781 }
18782 Py_INCREF(Py_None); resultobj = Py_None;
18783 return resultobj;
18784 fail:
18785 return NULL;
18786 }
18787
18788
18789 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18790 PyObject *resultobj;
18791 wxDateTime::Country result;
18792 char *kwnames[] = {
18793 NULL
18794 };
18795
18796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18797 {
18798 PyThreadState* __tstate = wxPyBeginAllowThreads();
18799 result = (wxDateTime::Country)wxDateTime::GetCountry();
18800
18801 wxPyEndAllowThreads(__tstate);
18802 if (PyErr_Occurred()) SWIG_fail;
18803 }
18804 resultobj = SWIG_From_int((result));
18805 return resultobj;
18806 fail:
18807 return NULL;
18808 }
18809
18810
18811 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18812 PyObject *resultobj;
18813 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18814 bool result;
18815 PyObject * obj0 = 0 ;
18816 char *kwnames[] = {
18817 (char *) "country", NULL
18818 };
18819
18820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18821 if (obj0) {
18822 {
18823 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18824 if (SWIG_arg_fail(1)) SWIG_fail;
18825 }
18826 }
18827 {
18828 PyThreadState* __tstate = wxPyBeginAllowThreads();
18829 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18830
18831 wxPyEndAllowThreads(__tstate);
18832 if (PyErr_Occurred()) SWIG_fail;
18833 }
18834 {
18835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18836 }
18837 return resultobj;
18838 fail:
18839 return NULL;
18840 }
18841
18842
18843 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18844 PyObject *resultobj;
18845 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18846 int result;
18847 PyObject * obj0 = 0 ;
18848 char *kwnames[] = {
18849 (char *) "cal", NULL
18850 };
18851
18852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18853 if (obj0) {
18854 {
18855 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18856 if (SWIG_arg_fail(1)) SWIG_fail;
18857 }
18858 }
18859 {
18860 PyThreadState* __tstate = wxPyBeginAllowThreads();
18861 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18862
18863 wxPyEndAllowThreads(__tstate);
18864 if (PyErr_Occurred()) SWIG_fail;
18865 }
18866 {
18867 resultobj = SWIG_From_int((int)(result));
18868 }
18869 return resultobj;
18870 fail:
18871 return NULL;
18872 }
18873
18874
18875 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
18876 PyObject *resultobj;
18877 int arg1 ;
18878 int result;
18879 PyObject * obj0 = 0 ;
18880 char *kwnames[] = {
18881 (char *) "year", NULL
18882 };
18883
18884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
18885 {
18886 arg1 = (int)(SWIG_As_int(obj0));
18887 if (SWIG_arg_fail(1)) SWIG_fail;
18888 }
18889 {
18890 PyThreadState* __tstate = wxPyBeginAllowThreads();
18891 result = (int)wxDateTime::ConvertYearToBC(arg1);
18892
18893 wxPyEndAllowThreads(__tstate);
18894 if (PyErr_Occurred()) SWIG_fail;
18895 }
18896 {
18897 resultobj = SWIG_From_int((int)(result));
18898 }
18899 return resultobj;
18900 fail:
18901 return NULL;
18902 }
18903
18904
18905 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18906 PyObject *resultobj;
18907 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18908 wxDateTime::Month result;
18909 PyObject * obj0 = 0 ;
18910 char *kwnames[] = {
18911 (char *) "cal", NULL
18912 };
18913
18914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
18915 if (obj0) {
18916 {
18917 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18918 if (SWIG_arg_fail(1)) SWIG_fail;
18919 }
18920 }
18921 {
18922 PyThreadState* __tstate = wxPyBeginAllowThreads();
18923 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
18924
18925 wxPyEndAllowThreads(__tstate);
18926 if (PyErr_Occurred()) SWIG_fail;
18927 }
18928 resultobj = SWIG_From_int((result));
18929 return resultobj;
18930 fail:
18931 return NULL;
18932 }
18933
18934
18935 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
18936 PyObject *resultobj;
18937 int arg1 = (int) wxDateTime::Inv_Year ;
18938 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18939 bool result;
18940 PyObject * obj0 = 0 ;
18941 PyObject * obj1 = 0 ;
18942 char *kwnames[] = {
18943 (char *) "year",(char *) "cal", NULL
18944 };
18945
18946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
18947 if (obj0) {
18948 {
18949 arg1 = (int)(SWIG_As_int(obj0));
18950 if (SWIG_arg_fail(1)) SWIG_fail;
18951 }
18952 }
18953 if (obj1) {
18954 {
18955 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18956 if (SWIG_arg_fail(2)) SWIG_fail;
18957 }
18958 }
18959 {
18960 PyThreadState* __tstate = wxPyBeginAllowThreads();
18961 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
18962
18963 wxPyEndAllowThreads(__tstate);
18964 if (PyErr_Occurred()) SWIG_fail;
18965 }
18966 {
18967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18968 }
18969 return resultobj;
18970 fail:
18971 return NULL;
18972 }
18973
18974
18975 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
18976 PyObject *resultobj;
18977 int arg1 = (int) wxDateTime::Inv_Year ;
18978 int result;
18979 PyObject * obj0 = 0 ;
18980 char *kwnames[] = {
18981 (char *) "year", NULL
18982 };
18983
18984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
18985 if (obj0) {
18986 {
18987 arg1 = (int)(SWIG_As_int(obj0));
18988 if (SWIG_arg_fail(1)) SWIG_fail;
18989 }
18990 }
18991 {
18992 PyThreadState* __tstate = wxPyBeginAllowThreads();
18993 result = (int)wxDateTime::GetCentury(arg1);
18994
18995 wxPyEndAllowThreads(__tstate);
18996 if (PyErr_Occurred()) SWIG_fail;
18997 }
18998 {
18999 resultobj = SWIG_From_int((int)(result));
19000 }
19001 return resultobj;
19002 fail:
19003 return NULL;
19004 }
19005
19006
19007 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19008 PyObject *resultobj;
19009 int arg1 ;
19010 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19011 int result;
19012 PyObject * obj0 = 0 ;
19013 PyObject * obj1 = 0 ;
19014 char *kwnames[] = {
19015 (char *) "year",(char *) "cal", NULL
19016 };
19017
19018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19019 {
19020 arg1 = (int)(SWIG_As_int(obj0));
19021 if (SWIG_arg_fail(1)) SWIG_fail;
19022 }
19023 if (obj1) {
19024 {
19025 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19026 if (SWIG_arg_fail(2)) SWIG_fail;
19027 }
19028 }
19029 {
19030 PyThreadState* __tstate = wxPyBeginAllowThreads();
19031 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19032
19033 wxPyEndAllowThreads(__tstate);
19034 if (PyErr_Occurred()) SWIG_fail;
19035 }
19036 {
19037 resultobj = SWIG_From_int((int)(result));
19038 }
19039 return resultobj;
19040 fail:
19041 return NULL;
19042 }
19043
19044
19045 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19046 PyObject *resultobj;
19047 wxDateTime::Month arg1 ;
19048 int arg2 = (int) wxDateTime::Inv_Year ;
19049 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19050 int result;
19051 PyObject * obj0 = 0 ;
19052 PyObject * obj1 = 0 ;
19053 PyObject * obj2 = 0 ;
19054 char *kwnames[] = {
19055 (char *) "month",(char *) "year",(char *) "cal", NULL
19056 };
19057
19058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19059 {
19060 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19061 if (SWIG_arg_fail(1)) SWIG_fail;
19062 }
19063 if (obj1) {
19064 {
19065 arg2 = (int)(SWIG_As_int(obj1));
19066 if (SWIG_arg_fail(2)) SWIG_fail;
19067 }
19068 }
19069 if (obj2) {
19070 {
19071 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19072 if (SWIG_arg_fail(3)) SWIG_fail;
19073 }
19074 }
19075 {
19076 PyThreadState* __tstate = wxPyBeginAllowThreads();
19077 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19078
19079 wxPyEndAllowThreads(__tstate);
19080 if (PyErr_Occurred()) SWIG_fail;
19081 }
19082 {
19083 resultobj = SWIG_From_int((int)(result));
19084 }
19085 return resultobj;
19086 fail:
19087 return NULL;
19088 }
19089
19090
19091 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19092 PyObject *resultobj;
19093 wxDateTime::Month arg1 ;
19094 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19095 wxString result;
19096 PyObject * obj0 = 0 ;
19097 PyObject * obj1 = 0 ;
19098 char *kwnames[] = {
19099 (char *) "month",(char *) "flags", NULL
19100 };
19101
19102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19103 {
19104 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19105 if (SWIG_arg_fail(1)) SWIG_fail;
19106 }
19107 if (obj1) {
19108 {
19109 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19110 if (SWIG_arg_fail(2)) SWIG_fail;
19111 }
19112 }
19113 {
19114 PyThreadState* __tstate = wxPyBeginAllowThreads();
19115 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19116
19117 wxPyEndAllowThreads(__tstate);
19118 if (PyErr_Occurred()) SWIG_fail;
19119 }
19120 {
19121 #if wxUSE_UNICODE
19122 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19123 #else
19124 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19125 #endif
19126 }
19127 return resultobj;
19128 fail:
19129 return NULL;
19130 }
19131
19132
19133 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19134 PyObject *resultobj;
19135 wxDateTime::WeekDay arg1 ;
19136 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19137 wxString result;
19138 PyObject * obj0 = 0 ;
19139 PyObject * obj1 = 0 ;
19140 char *kwnames[] = {
19141 (char *) "weekday",(char *) "flags", NULL
19142 };
19143
19144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19145 {
19146 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19147 if (SWIG_arg_fail(1)) SWIG_fail;
19148 }
19149 if (obj1) {
19150 {
19151 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19152 if (SWIG_arg_fail(2)) SWIG_fail;
19153 }
19154 }
19155 {
19156 PyThreadState* __tstate = wxPyBeginAllowThreads();
19157 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19158
19159 wxPyEndAllowThreads(__tstate);
19160 if (PyErr_Occurred()) SWIG_fail;
19161 }
19162 {
19163 #if wxUSE_UNICODE
19164 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19165 #else
19166 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19167 #endif
19168 }
19169 return resultobj;
19170 fail:
19171 return NULL;
19172 }
19173
19174
19175 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19176 PyObject *resultobj;
19177 wxString *arg1 = (wxString *) 0 ;
19178 wxString *arg2 = (wxString *) 0 ;
19179 bool temp1 = false ;
19180 bool temp2 = false ;
19181 PyObject * obj0 = 0 ;
19182 PyObject * obj1 = 0 ;
19183 char *kwnames[] = {
19184 (char *) "OUTPUT",(char *) "OUTPUT", NULL
19185 };
19186
19187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
19188 {
19189 arg1 = wxString_in_helper(obj0);
19190 if (arg1 == NULL) SWIG_fail;
19191 temp1 = true;
19192 }
19193 {
19194 arg2 = wxString_in_helper(obj1);
19195 if (arg2 == NULL) SWIG_fail;
19196 temp2 = true;
19197 }
19198 {
19199 PyThreadState* __tstate = wxPyBeginAllowThreads();
19200 wxDateTime::GetAmPmStrings(arg1,arg2);
19201
19202 wxPyEndAllowThreads(__tstate);
19203 if (PyErr_Occurred()) SWIG_fail;
19204 }
19205 Py_INCREF(Py_None); resultobj = Py_None;
19206 {
19207 if (temp1)
19208 delete arg1;
19209 }
19210 {
19211 if (temp2)
19212 delete arg2;
19213 }
19214 return resultobj;
19215 fail:
19216 {
19217 if (temp1)
19218 delete arg1;
19219 }
19220 {
19221 if (temp2)
19222 delete arg2;
19223 }
19224 return NULL;
19225 }
19226
19227
19228 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19229 PyObject *resultobj;
19230 int arg1 = (int) wxDateTime::Inv_Year ;
19231 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19232 bool result;
19233 PyObject * obj0 = 0 ;
19234 PyObject * obj1 = 0 ;
19235 char *kwnames[] = {
19236 (char *) "year",(char *) "country", NULL
19237 };
19238
19239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19240 if (obj0) {
19241 {
19242 arg1 = (int)(SWIG_As_int(obj0));
19243 if (SWIG_arg_fail(1)) SWIG_fail;
19244 }
19245 }
19246 if (obj1) {
19247 {
19248 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19249 if (SWIG_arg_fail(2)) SWIG_fail;
19250 }
19251 }
19252 {
19253 PyThreadState* __tstate = wxPyBeginAllowThreads();
19254 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19255
19256 wxPyEndAllowThreads(__tstate);
19257 if (PyErr_Occurred()) SWIG_fail;
19258 }
19259 {
19260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19261 }
19262 return resultobj;
19263 fail:
19264 return NULL;
19265 }
19266
19267
19268 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19269 PyObject *resultobj;
19270 int arg1 = (int) wxDateTime::Inv_Year ;
19271 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19272 wxDateTime result;
19273 PyObject * obj0 = 0 ;
19274 PyObject * obj1 = 0 ;
19275 char *kwnames[] = {
19276 (char *) "year",(char *) "country", NULL
19277 };
19278
19279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19280 if (obj0) {
19281 {
19282 arg1 = (int)(SWIG_As_int(obj0));
19283 if (SWIG_arg_fail(1)) SWIG_fail;
19284 }
19285 }
19286 if (obj1) {
19287 {
19288 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19289 if (SWIG_arg_fail(2)) SWIG_fail;
19290 }
19291 }
19292 {
19293 PyThreadState* __tstate = wxPyBeginAllowThreads();
19294 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19295
19296 wxPyEndAllowThreads(__tstate);
19297 if (PyErr_Occurred()) SWIG_fail;
19298 }
19299 {
19300 wxDateTime * resultptr;
19301 resultptr = new wxDateTime((wxDateTime &)(result));
19302 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19303 }
19304 return resultobj;
19305 fail:
19306 return NULL;
19307 }
19308
19309
19310 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19311 PyObject *resultobj;
19312 int arg1 = (int) wxDateTime::Inv_Year ;
19313 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19314 wxDateTime result;
19315 PyObject * obj0 = 0 ;
19316 PyObject * obj1 = 0 ;
19317 char *kwnames[] = {
19318 (char *) "year",(char *) "country", NULL
19319 };
19320
19321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19322 if (obj0) {
19323 {
19324 arg1 = (int)(SWIG_As_int(obj0));
19325 if (SWIG_arg_fail(1)) SWIG_fail;
19326 }
19327 }
19328 if (obj1) {
19329 {
19330 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19331 if (SWIG_arg_fail(2)) SWIG_fail;
19332 }
19333 }
19334 {
19335 PyThreadState* __tstate = wxPyBeginAllowThreads();
19336 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19337
19338 wxPyEndAllowThreads(__tstate);
19339 if (PyErr_Occurred()) SWIG_fail;
19340 }
19341 {
19342 wxDateTime * resultptr;
19343 resultptr = new wxDateTime((wxDateTime &)(result));
19344 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19345 }
19346 return resultobj;
19347 fail:
19348 return NULL;
19349 }
19350
19351
19352 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19353 PyObject *resultobj;
19354 wxDateTime result;
19355 char *kwnames[] = {
19356 NULL
19357 };
19358
19359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19360 {
19361 PyThreadState* __tstate = wxPyBeginAllowThreads();
19362 result = wxDateTime::Now();
19363
19364 wxPyEndAllowThreads(__tstate);
19365 if (PyErr_Occurred()) SWIG_fail;
19366 }
19367 {
19368 wxDateTime * resultptr;
19369 resultptr = new wxDateTime((wxDateTime &)(result));
19370 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19371 }
19372 return resultobj;
19373 fail:
19374 return NULL;
19375 }
19376
19377
19378 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19379 PyObject *resultobj;
19380 wxDateTime result;
19381 char *kwnames[] = {
19382 NULL
19383 };
19384
19385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19386 {
19387 PyThreadState* __tstate = wxPyBeginAllowThreads();
19388 result = wxDateTime::UNow();
19389
19390 wxPyEndAllowThreads(__tstate);
19391 if (PyErr_Occurred()) SWIG_fail;
19392 }
19393 {
19394 wxDateTime * resultptr;
19395 resultptr = new wxDateTime((wxDateTime &)(result));
19396 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19397 }
19398 return resultobj;
19399 fail:
19400 return NULL;
19401 }
19402
19403
19404 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19405 PyObject *resultobj;
19406 wxDateTime result;
19407 char *kwnames[] = {
19408 NULL
19409 };
19410
19411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19412 {
19413 PyThreadState* __tstate = wxPyBeginAllowThreads();
19414 result = wxDateTime::Today();
19415
19416 wxPyEndAllowThreads(__tstate);
19417 if (PyErr_Occurred()) SWIG_fail;
19418 }
19419 {
19420 wxDateTime * resultptr;
19421 resultptr = new wxDateTime((wxDateTime &)(result));
19422 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19423 }
19424 return resultobj;
19425 fail:
19426 return NULL;
19427 }
19428
19429
19430 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19431 PyObject *resultobj;
19432 wxDateTime *result;
19433 char *kwnames[] = {
19434 NULL
19435 };
19436
19437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19438 {
19439 PyThreadState* __tstate = wxPyBeginAllowThreads();
19440 result = (wxDateTime *)new wxDateTime();
19441
19442 wxPyEndAllowThreads(__tstate);
19443 if (PyErr_Occurred()) SWIG_fail;
19444 }
19445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19446 return resultobj;
19447 fail:
19448 return NULL;
19449 }
19450
19451
19452 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19453 PyObject *resultobj;
19454 time_t arg1 ;
19455 wxDateTime *result;
19456 PyObject * obj0 = 0 ;
19457 char *kwnames[] = {
19458 (char *) "timet", NULL
19459 };
19460
19461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19462 {
19463 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19464 if (SWIG_arg_fail(1)) SWIG_fail;
19465 }
19466 {
19467 PyThreadState* __tstate = wxPyBeginAllowThreads();
19468 result = (wxDateTime *)new wxDateTime(arg1);
19469
19470 wxPyEndAllowThreads(__tstate);
19471 if (PyErr_Occurred()) SWIG_fail;
19472 }
19473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19474 return resultobj;
19475 fail:
19476 return NULL;
19477 }
19478
19479
19480 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19481 PyObject *resultobj;
19482 double arg1 ;
19483 wxDateTime *result;
19484 PyObject * obj0 = 0 ;
19485 char *kwnames[] = {
19486 (char *) "jdn", NULL
19487 };
19488
19489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19490 {
19491 arg1 = (double)(SWIG_As_double(obj0));
19492 if (SWIG_arg_fail(1)) SWIG_fail;
19493 }
19494 {
19495 PyThreadState* __tstate = wxPyBeginAllowThreads();
19496 result = (wxDateTime *)new wxDateTime(arg1);
19497
19498 wxPyEndAllowThreads(__tstate);
19499 if (PyErr_Occurred()) SWIG_fail;
19500 }
19501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19502 return resultobj;
19503 fail:
19504 return NULL;
19505 }
19506
19507
19508 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19509 PyObject *resultobj;
19510 int arg1 ;
19511 int arg2 = (int) 0 ;
19512 int arg3 = (int) 0 ;
19513 int arg4 = (int) 0 ;
19514 wxDateTime *result;
19515 PyObject * obj0 = 0 ;
19516 PyObject * obj1 = 0 ;
19517 PyObject * obj2 = 0 ;
19518 PyObject * obj3 = 0 ;
19519 char *kwnames[] = {
19520 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19521 };
19522
19523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19524 {
19525 arg1 = (int)(SWIG_As_int(obj0));
19526 if (SWIG_arg_fail(1)) SWIG_fail;
19527 }
19528 if (obj1) {
19529 {
19530 arg2 = (int)(SWIG_As_int(obj1));
19531 if (SWIG_arg_fail(2)) SWIG_fail;
19532 }
19533 }
19534 if (obj2) {
19535 {
19536 arg3 = (int)(SWIG_As_int(obj2));
19537 if (SWIG_arg_fail(3)) SWIG_fail;
19538 }
19539 }
19540 if (obj3) {
19541 {
19542 arg4 = (int)(SWIG_As_int(obj3));
19543 if (SWIG_arg_fail(4)) SWIG_fail;
19544 }
19545 }
19546 {
19547 PyThreadState* __tstate = wxPyBeginAllowThreads();
19548 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19549
19550 wxPyEndAllowThreads(__tstate);
19551 if (PyErr_Occurred()) SWIG_fail;
19552 }
19553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19561 PyObject *resultobj;
19562 int arg1 ;
19563 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19564 int arg3 = (int) wxDateTime::Inv_Year ;
19565 int arg4 = (int) 0 ;
19566 int arg5 = (int) 0 ;
19567 int arg6 = (int) 0 ;
19568 int arg7 = (int) 0 ;
19569 wxDateTime *result;
19570 PyObject * obj0 = 0 ;
19571 PyObject * obj1 = 0 ;
19572 PyObject * obj2 = 0 ;
19573 PyObject * obj3 = 0 ;
19574 PyObject * obj4 = 0 ;
19575 PyObject * obj5 = 0 ;
19576 PyObject * obj6 = 0 ;
19577 char *kwnames[] = {
19578 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19579 };
19580
19581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19582 {
19583 arg1 = (int)(SWIG_As_int(obj0));
19584 if (SWIG_arg_fail(1)) SWIG_fail;
19585 }
19586 if (obj1) {
19587 {
19588 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19589 if (SWIG_arg_fail(2)) SWIG_fail;
19590 }
19591 }
19592 if (obj2) {
19593 {
19594 arg3 = (int)(SWIG_As_int(obj2));
19595 if (SWIG_arg_fail(3)) SWIG_fail;
19596 }
19597 }
19598 if (obj3) {
19599 {
19600 arg4 = (int)(SWIG_As_int(obj3));
19601 if (SWIG_arg_fail(4)) SWIG_fail;
19602 }
19603 }
19604 if (obj4) {
19605 {
19606 arg5 = (int)(SWIG_As_int(obj4));
19607 if (SWIG_arg_fail(5)) SWIG_fail;
19608 }
19609 }
19610 if (obj5) {
19611 {
19612 arg6 = (int)(SWIG_As_int(obj5));
19613 if (SWIG_arg_fail(6)) SWIG_fail;
19614 }
19615 }
19616 if (obj6) {
19617 {
19618 arg7 = (int)(SWIG_As_int(obj6));
19619 if (SWIG_arg_fail(7)) SWIG_fail;
19620 }
19621 }
19622 {
19623 PyThreadState* __tstate = wxPyBeginAllowThreads();
19624 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19625
19626 wxPyEndAllowThreads(__tstate);
19627 if (PyErr_Occurred()) SWIG_fail;
19628 }
19629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19630 return resultobj;
19631 fail:
19632 return NULL;
19633 }
19634
19635
19636 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19637 PyObject *resultobj;
19638 wxDateTime *arg1 = (wxDateTime *) 0 ;
19639 PyObject * obj0 = 0 ;
19640 char *kwnames[] = {
19641 (char *) "self", NULL
19642 };
19643
19644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19646 if (SWIG_arg_fail(1)) SWIG_fail;
19647 {
19648 PyThreadState* __tstate = wxPyBeginAllowThreads();
19649 delete arg1;
19650
19651 wxPyEndAllowThreads(__tstate);
19652 if (PyErr_Occurred()) SWIG_fail;
19653 }
19654 Py_INCREF(Py_None); resultobj = Py_None;
19655 return resultobj;
19656 fail:
19657 return NULL;
19658 }
19659
19660
19661 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19662 PyObject *resultobj;
19663 wxDateTime *arg1 = (wxDateTime *) 0 ;
19664 wxDateTime *result;
19665 PyObject * obj0 = 0 ;
19666 char *kwnames[] = {
19667 (char *) "self", NULL
19668 };
19669
19670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19672 if (SWIG_arg_fail(1)) SWIG_fail;
19673 {
19674 PyThreadState* __tstate = wxPyBeginAllowThreads();
19675 {
19676 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19677 result = (wxDateTime *) &_result_ref;
19678 }
19679
19680 wxPyEndAllowThreads(__tstate);
19681 if (PyErr_Occurred()) SWIG_fail;
19682 }
19683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19684 return resultobj;
19685 fail:
19686 return NULL;
19687 }
19688
19689
19690 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19691 PyObject *resultobj;
19692 wxDateTime *arg1 = (wxDateTime *) 0 ;
19693 time_t arg2 ;
19694 wxDateTime *result;
19695 PyObject * obj0 = 0 ;
19696 PyObject * obj1 = 0 ;
19697 char *kwnames[] = {
19698 (char *) "self",(char *) "timet", NULL
19699 };
19700
19701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19703 if (SWIG_arg_fail(1)) SWIG_fail;
19704 {
19705 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19706 if (SWIG_arg_fail(2)) SWIG_fail;
19707 }
19708 {
19709 PyThreadState* __tstate = wxPyBeginAllowThreads();
19710 {
19711 wxDateTime &_result_ref = (arg1)->Set(arg2);
19712 result = (wxDateTime *) &_result_ref;
19713 }
19714
19715 wxPyEndAllowThreads(__tstate);
19716 if (PyErr_Occurred()) SWIG_fail;
19717 }
19718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19719 return resultobj;
19720 fail:
19721 return NULL;
19722 }
19723
19724
19725 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19726 PyObject *resultobj;
19727 wxDateTime *arg1 = (wxDateTime *) 0 ;
19728 double arg2 ;
19729 wxDateTime *result;
19730 PyObject * obj0 = 0 ;
19731 PyObject * obj1 = 0 ;
19732 char *kwnames[] = {
19733 (char *) "self",(char *) "jdn", NULL
19734 };
19735
19736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19738 if (SWIG_arg_fail(1)) SWIG_fail;
19739 {
19740 arg2 = (double)(SWIG_As_double(obj1));
19741 if (SWIG_arg_fail(2)) SWIG_fail;
19742 }
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 {
19746 wxDateTime &_result_ref = (arg1)->Set(arg2);
19747 result = (wxDateTime *) &_result_ref;
19748 }
19749
19750 wxPyEndAllowThreads(__tstate);
19751 if (PyErr_Occurred()) SWIG_fail;
19752 }
19753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19754 return resultobj;
19755 fail:
19756 return NULL;
19757 }
19758
19759
19760 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19761 PyObject *resultobj;
19762 wxDateTime *arg1 = (wxDateTime *) 0 ;
19763 int arg2 ;
19764 int arg3 = (int) 0 ;
19765 int arg4 = (int) 0 ;
19766 int arg5 = (int) 0 ;
19767 wxDateTime *result;
19768 PyObject * obj0 = 0 ;
19769 PyObject * obj1 = 0 ;
19770 PyObject * obj2 = 0 ;
19771 PyObject * obj3 = 0 ;
19772 PyObject * obj4 = 0 ;
19773 char *kwnames[] = {
19774 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19775 };
19776
19777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19779 if (SWIG_arg_fail(1)) SWIG_fail;
19780 {
19781 arg2 = (int)(SWIG_As_int(obj1));
19782 if (SWIG_arg_fail(2)) SWIG_fail;
19783 }
19784 if (obj2) {
19785 {
19786 arg3 = (int)(SWIG_As_int(obj2));
19787 if (SWIG_arg_fail(3)) SWIG_fail;
19788 }
19789 }
19790 if (obj3) {
19791 {
19792 arg4 = (int)(SWIG_As_int(obj3));
19793 if (SWIG_arg_fail(4)) SWIG_fail;
19794 }
19795 }
19796 if (obj4) {
19797 {
19798 arg5 = (int)(SWIG_As_int(obj4));
19799 if (SWIG_arg_fail(5)) SWIG_fail;
19800 }
19801 }
19802 {
19803 PyThreadState* __tstate = wxPyBeginAllowThreads();
19804 {
19805 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19806 result = (wxDateTime *) &_result_ref;
19807 }
19808
19809 wxPyEndAllowThreads(__tstate);
19810 if (PyErr_Occurred()) SWIG_fail;
19811 }
19812 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19813 return resultobj;
19814 fail:
19815 return NULL;
19816 }
19817
19818
19819 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19820 PyObject *resultobj;
19821 wxDateTime *arg1 = (wxDateTime *) 0 ;
19822 int arg2 ;
19823 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19824 int arg4 = (int) wxDateTime::Inv_Year ;
19825 int arg5 = (int) 0 ;
19826 int arg6 = (int) 0 ;
19827 int arg7 = (int) 0 ;
19828 int arg8 = (int) 0 ;
19829 wxDateTime *result;
19830 PyObject * obj0 = 0 ;
19831 PyObject * obj1 = 0 ;
19832 PyObject * obj2 = 0 ;
19833 PyObject * obj3 = 0 ;
19834 PyObject * obj4 = 0 ;
19835 PyObject * obj5 = 0 ;
19836 PyObject * obj6 = 0 ;
19837 PyObject * obj7 = 0 ;
19838 char *kwnames[] = {
19839 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19840 };
19841
19842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19844 if (SWIG_arg_fail(1)) SWIG_fail;
19845 {
19846 arg2 = (int)(SWIG_As_int(obj1));
19847 if (SWIG_arg_fail(2)) SWIG_fail;
19848 }
19849 if (obj2) {
19850 {
19851 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19852 if (SWIG_arg_fail(3)) SWIG_fail;
19853 }
19854 }
19855 if (obj3) {
19856 {
19857 arg4 = (int)(SWIG_As_int(obj3));
19858 if (SWIG_arg_fail(4)) SWIG_fail;
19859 }
19860 }
19861 if (obj4) {
19862 {
19863 arg5 = (int)(SWIG_As_int(obj4));
19864 if (SWIG_arg_fail(5)) SWIG_fail;
19865 }
19866 }
19867 if (obj5) {
19868 {
19869 arg6 = (int)(SWIG_As_int(obj5));
19870 if (SWIG_arg_fail(6)) SWIG_fail;
19871 }
19872 }
19873 if (obj6) {
19874 {
19875 arg7 = (int)(SWIG_As_int(obj6));
19876 if (SWIG_arg_fail(7)) SWIG_fail;
19877 }
19878 }
19879 if (obj7) {
19880 {
19881 arg8 = (int)(SWIG_As_int(obj7));
19882 if (SWIG_arg_fail(8)) SWIG_fail;
19883 }
19884 }
19885 {
19886 PyThreadState* __tstate = wxPyBeginAllowThreads();
19887 {
19888 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
19889 result = (wxDateTime *) &_result_ref;
19890 }
19891
19892 wxPyEndAllowThreads(__tstate);
19893 if (PyErr_Occurred()) SWIG_fail;
19894 }
19895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19896 return resultobj;
19897 fail:
19898 return NULL;
19899 }
19900
19901
19902 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
19903 PyObject *resultobj;
19904 wxDateTime *arg1 = (wxDateTime *) 0 ;
19905 wxDateTime *result;
19906 PyObject * obj0 = 0 ;
19907 char *kwnames[] = {
19908 (char *) "self", NULL
19909 };
19910
19911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
19912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19913 if (SWIG_arg_fail(1)) SWIG_fail;
19914 {
19915 PyThreadState* __tstate = wxPyBeginAllowThreads();
19916 {
19917 wxDateTime &_result_ref = (arg1)->ResetTime();
19918 result = (wxDateTime *) &_result_ref;
19919 }
19920
19921 wxPyEndAllowThreads(__tstate);
19922 if (PyErr_Occurred()) SWIG_fail;
19923 }
19924 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19925 return resultobj;
19926 fail:
19927 return NULL;
19928 }
19929
19930
19931 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
19932 PyObject *resultobj;
19933 wxDateTime *arg1 = (wxDateTime *) 0 ;
19934 int arg2 ;
19935 wxDateTime *result;
19936 PyObject * obj0 = 0 ;
19937 PyObject * obj1 = 0 ;
19938 char *kwnames[] = {
19939 (char *) "self",(char *) "year", NULL
19940 };
19941
19942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
19943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19944 if (SWIG_arg_fail(1)) SWIG_fail;
19945 {
19946 arg2 = (int)(SWIG_As_int(obj1));
19947 if (SWIG_arg_fail(2)) SWIG_fail;
19948 }
19949 {
19950 PyThreadState* __tstate = wxPyBeginAllowThreads();
19951 {
19952 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
19953 result = (wxDateTime *) &_result_ref;
19954 }
19955
19956 wxPyEndAllowThreads(__tstate);
19957 if (PyErr_Occurred()) SWIG_fail;
19958 }
19959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19960 return resultobj;
19961 fail:
19962 return NULL;
19963 }
19964
19965
19966 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19967 PyObject *resultobj;
19968 wxDateTime *arg1 = (wxDateTime *) 0 ;
19969 wxDateTime::Month arg2 ;
19970 wxDateTime *result;
19971 PyObject * obj0 = 0 ;
19972 PyObject * obj1 = 0 ;
19973 char *kwnames[] = {
19974 (char *) "self",(char *) "month", NULL
19975 };
19976
19977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
19978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19979 if (SWIG_arg_fail(1)) SWIG_fail;
19980 {
19981 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19982 if (SWIG_arg_fail(2)) SWIG_fail;
19983 }
19984 {
19985 PyThreadState* __tstate = wxPyBeginAllowThreads();
19986 {
19987 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
19988 result = (wxDateTime *) &_result_ref;
19989 }
19990
19991 wxPyEndAllowThreads(__tstate);
19992 if (PyErr_Occurred()) SWIG_fail;
19993 }
19994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19995 return resultobj;
19996 fail:
19997 return NULL;
19998 }
19999
20000
20001 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20002 PyObject *resultobj;
20003 wxDateTime *arg1 = (wxDateTime *) 0 ;
20004 int arg2 ;
20005 wxDateTime *result;
20006 PyObject * obj0 = 0 ;
20007 PyObject * obj1 = 0 ;
20008 char *kwnames[] = {
20009 (char *) "self",(char *) "day", NULL
20010 };
20011
20012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20014 if (SWIG_arg_fail(1)) SWIG_fail;
20015 {
20016 arg2 = (int)(SWIG_As_int(obj1));
20017 if (SWIG_arg_fail(2)) SWIG_fail;
20018 }
20019 {
20020 PyThreadState* __tstate = wxPyBeginAllowThreads();
20021 {
20022 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20023 result = (wxDateTime *) &_result_ref;
20024 }
20025
20026 wxPyEndAllowThreads(__tstate);
20027 if (PyErr_Occurred()) SWIG_fail;
20028 }
20029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20030 return resultobj;
20031 fail:
20032 return NULL;
20033 }
20034
20035
20036 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20037 PyObject *resultobj;
20038 wxDateTime *arg1 = (wxDateTime *) 0 ;
20039 int arg2 ;
20040 wxDateTime *result;
20041 PyObject * obj0 = 0 ;
20042 PyObject * obj1 = 0 ;
20043 char *kwnames[] = {
20044 (char *) "self",(char *) "hour", NULL
20045 };
20046
20047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20049 if (SWIG_arg_fail(1)) SWIG_fail;
20050 {
20051 arg2 = (int)(SWIG_As_int(obj1));
20052 if (SWIG_arg_fail(2)) SWIG_fail;
20053 }
20054 {
20055 PyThreadState* __tstate = wxPyBeginAllowThreads();
20056 {
20057 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20058 result = (wxDateTime *) &_result_ref;
20059 }
20060
20061 wxPyEndAllowThreads(__tstate);
20062 if (PyErr_Occurred()) SWIG_fail;
20063 }
20064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20065 return resultobj;
20066 fail:
20067 return NULL;
20068 }
20069
20070
20071 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20072 PyObject *resultobj;
20073 wxDateTime *arg1 = (wxDateTime *) 0 ;
20074 int arg2 ;
20075 wxDateTime *result;
20076 PyObject * obj0 = 0 ;
20077 PyObject * obj1 = 0 ;
20078 char *kwnames[] = {
20079 (char *) "self",(char *) "minute", NULL
20080 };
20081
20082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20084 if (SWIG_arg_fail(1)) SWIG_fail;
20085 {
20086 arg2 = (int)(SWIG_As_int(obj1));
20087 if (SWIG_arg_fail(2)) SWIG_fail;
20088 }
20089 {
20090 PyThreadState* __tstate = wxPyBeginAllowThreads();
20091 {
20092 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20093 result = (wxDateTime *) &_result_ref;
20094 }
20095
20096 wxPyEndAllowThreads(__tstate);
20097 if (PyErr_Occurred()) SWIG_fail;
20098 }
20099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20100 return resultobj;
20101 fail:
20102 return NULL;
20103 }
20104
20105
20106 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20107 PyObject *resultobj;
20108 wxDateTime *arg1 = (wxDateTime *) 0 ;
20109 int arg2 ;
20110 wxDateTime *result;
20111 PyObject * obj0 = 0 ;
20112 PyObject * obj1 = 0 ;
20113 char *kwnames[] = {
20114 (char *) "self",(char *) "second", NULL
20115 };
20116
20117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20119 if (SWIG_arg_fail(1)) SWIG_fail;
20120 {
20121 arg2 = (int)(SWIG_As_int(obj1));
20122 if (SWIG_arg_fail(2)) SWIG_fail;
20123 }
20124 {
20125 PyThreadState* __tstate = wxPyBeginAllowThreads();
20126 {
20127 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20128 result = (wxDateTime *) &_result_ref;
20129 }
20130
20131 wxPyEndAllowThreads(__tstate);
20132 if (PyErr_Occurred()) SWIG_fail;
20133 }
20134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20135 return resultobj;
20136 fail:
20137 return NULL;
20138 }
20139
20140
20141 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20142 PyObject *resultobj;
20143 wxDateTime *arg1 = (wxDateTime *) 0 ;
20144 int arg2 ;
20145 wxDateTime *result;
20146 PyObject * obj0 = 0 ;
20147 PyObject * obj1 = 0 ;
20148 char *kwnames[] = {
20149 (char *) "self",(char *) "millisecond", NULL
20150 };
20151
20152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20154 if (SWIG_arg_fail(1)) SWIG_fail;
20155 {
20156 arg2 = (int)(SWIG_As_int(obj1));
20157 if (SWIG_arg_fail(2)) SWIG_fail;
20158 }
20159 {
20160 PyThreadState* __tstate = wxPyBeginAllowThreads();
20161 {
20162 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20163 result = (wxDateTime *) &_result_ref;
20164 }
20165
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20177 PyObject *resultobj;
20178 wxDateTime *arg1 = (wxDateTime *) 0 ;
20179 wxDateTime::WeekDay arg2 ;
20180 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20181 wxDateTime *result;
20182 PyObject * obj0 = 0 ;
20183 PyObject * obj1 = 0 ;
20184 PyObject * obj2 = 0 ;
20185 char *kwnames[] = {
20186 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20187 };
20188
20189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20191 if (SWIG_arg_fail(1)) SWIG_fail;
20192 {
20193 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20194 if (SWIG_arg_fail(2)) SWIG_fail;
20195 }
20196 if (obj2) {
20197 {
20198 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20199 if (SWIG_arg_fail(3)) SWIG_fail;
20200 }
20201 }
20202 {
20203 PyThreadState* __tstate = wxPyBeginAllowThreads();
20204 {
20205 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20206 result = (wxDateTime *) &_result_ref;
20207 }
20208
20209 wxPyEndAllowThreads(__tstate);
20210 if (PyErr_Occurred()) SWIG_fail;
20211 }
20212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20213 return resultobj;
20214 fail:
20215 return NULL;
20216 }
20217
20218
20219 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20220 PyObject *resultobj;
20221 wxDateTime *arg1 = (wxDateTime *) 0 ;
20222 wxDateTime::WeekDay arg2 ;
20223 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20224 wxDateTime result;
20225 PyObject * obj0 = 0 ;
20226 PyObject * obj1 = 0 ;
20227 PyObject * obj2 = 0 ;
20228 char *kwnames[] = {
20229 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20230 };
20231
20232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20234 if (SWIG_arg_fail(1)) SWIG_fail;
20235 {
20236 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20237 if (SWIG_arg_fail(2)) SWIG_fail;
20238 }
20239 if (obj2) {
20240 {
20241 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20242 if (SWIG_arg_fail(3)) SWIG_fail;
20243 }
20244 }
20245 {
20246 PyThreadState* __tstate = wxPyBeginAllowThreads();
20247 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20248
20249 wxPyEndAllowThreads(__tstate);
20250 if (PyErr_Occurred()) SWIG_fail;
20251 }
20252 {
20253 wxDateTime * resultptr;
20254 resultptr = new wxDateTime((wxDateTime &)(result));
20255 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20256 }
20257 return resultobj;
20258 fail:
20259 return NULL;
20260 }
20261
20262
20263 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20264 PyObject *resultobj;
20265 wxDateTime *arg1 = (wxDateTime *) 0 ;
20266 wxDateTime::WeekDay arg2 ;
20267 wxDateTime *result;
20268 PyObject * obj0 = 0 ;
20269 PyObject * obj1 = 0 ;
20270 char *kwnames[] = {
20271 (char *) "self",(char *) "weekday", NULL
20272 };
20273
20274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20276 if (SWIG_arg_fail(1)) SWIG_fail;
20277 {
20278 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20279 if (SWIG_arg_fail(2)) SWIG_fail;
20280 }
20281 {
20282 PyThreadState* __tstate = wxPyBeginAllowThreads();
20283 {
20284 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20285 result = (wxDateTime *) &_result_ref;
20286 }
20287
20288 wxPyEndAllowThreads(__tstate);
20289 if (PyErr_Occurred()) SWIG_fail;
20290 }
20291 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20292 return resultobj;
20293 fail:
20294 return NULL;
20295 }
20296
20297
20298 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20299 PyObject *resultobj;
20300 wxDateTime *arg1 = (wxDateTime *) 0 ;
20301 wxDateTime::WeekDay arg2 ;
20302 wxDateTime result;
20303 PyObject * obj0 = 0 ;
20304 PyObject * obj1 = 0 ;
20305 char *kwnames[] = {
20306 (char *) "self",(char *) "weekday", NULL
20307 };
20308
20309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20311 if (SWIG_arg_fail(1)) SWIG_fail;
20312 {
20313 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20314 if (SWIG_arg_fail(2)) SWIG_fail;
20315 }
20316 {
20317 PyThreadState* __tstate = wxPyBeginAllowThreads();
20318 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20319
20320 wxPyEndAllowThreads(__tstate);
20321 if (PyErr_Occurred()) SWIG_fail;
20322 }
20323 {
20324 wxDateTime * resultptr;
20325 resultptr = new wxDateTime((wxDateTime &)(result));
20326 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20327 }
20328 return resultobj;
20329 fail:
20330 return NULL;
20331 }
20332
20333
20334 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20335 PyObject *resultobj;
20336 wxDateTime *arg1 = (wxDateTime *) 0 ;
20337 wxDateTime::WeekDay arg2 ;
20338 wxDateTime *result;
20339 PyObject * obj0 = 0 ;
20340 PyObject * obj1 = 0 ;
20341 char *kwnames[] = {
20342 (char *) "self",(char *) "weekday", NULL
20343 };
20344
20345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20347 if (SWIG_arg_fail(1)) SWIG_fail;
20348 {
20349 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20350 if (SWIG_arg_fail(2)) SWIG_fail;
20351 }
20352 {
20353 PyThreadState* __tstate = wxPyBeginAllowThreads();
20354 {
20355 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20356 result = (wxDateTime *) &_result_ref;
20357 }
20358
20359 wxPyEndAllowThreads(__tstate);
20360 if (PyErr_Occurred()) SWIG_fail;
20361 }
20362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20363 return resultobj;
20364 fail:
20365 return NULL;
20366 }
20367
20368
20369 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20370 PyObject *resultobj;
20371 wxDateTime *arg1 = (wxDateTime *) 0 ;
20372 wxDateTime::WeekDay arg2 ;
20373 wxDateTime result;
20374 PyObject * obj0 = 0 ;
20375 PyObject * obj1 = 0 ;
20376 char *kwnames[] = {
20377 (char *) "self",(char *) "weekday", NULL
20378 };
20379
20380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20382 if (SWIG_arg_fail(1)) SWIG_fail;
20383 {
20384 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20385 if (SWIG_arg_fail(2)) SWIG_fail;
20386 }
20387 {
20388 PyThreadState* __tstate = wxPyBeginAllowThreads();
20389 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20390
20391 wxPyEndAllowThreads(__tstate);
20392 if (PyErr_Occurred()) SWIG_fail;
20393 }
20394 {
20395 wxDateTime * resultptr;
20396 resultptr = new wxDateTime((wxDateTime &)(result));
20397 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20398 }
20399 return resultobj;
20400 fail:
20401 return NULL;
20402 }
20403
20404
20405 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20406 PyObject *resultobj;
20407 wxDateTime *arg1 = (wxDateTime *) 0 ;
20408 wxDateTime::WeekDay arg2 ;
20409 int arg3 = (int) 1 ;
20410 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20411 int arg5 = (int) wxDateTime::Inv_Year ;
20412 bool result;
20413 PyObject * obj0 = 0 ;
20414 PyObject * obj1 = 0 ;
20415 PyObject * obj2 = 0 ;
20416 PyObject * obj3 = 0 ;
20417 PyObject * obj4 = 0 ;
20418 char *kwnames[] = {
20419 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20420 };
20421
20422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20424 if (SWIG_arg_fail(1)) SWIG_fail;
20425 {
20426 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20427 if (SWIG_arg_fail(2)) SWIG_fail;
20428 }
20429 if (obj2) {
20430 {
20431 arg3 = (int)(SWIG_As_int(obj2));
20432 if (SWIG_arg_fail(3)) SWIG_fail;
20433 }
20434 }
20435 if (obj3) {
20436 {
20437 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20438 if (SWIG_arg_fail(4)) SWIG_fail;
20439 }
20440 }
20441 if (obj4) {
20442 {
20443 arg5 = (int)(SWIG_As_int(obj4));
20444 if (SWIG_arg_fail(5)) SWIG_fail;
20445 }
20446 }
20447 {
20448 PyThreadState* __tstate = wxPyBeginAllowThreads();
20449 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20450
20451 wxPyEndAllowThreads(__tstate);
20452 if (PyErr_Occurred()) SWIG_fail;
20453 }
20454 {
20455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20456 }
20457 return resultobj;
20458 fail:
20459 return NULL;
20460 }
20461
20462
20463 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20464 PyObject *resultobj;
20465 wxDateTime *arg1 = (wxDateTime *) 0 ;
20466 wxDateTime::WeekDay arg2 ;
20467 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20468 int arg4 = (int) wxDateTime::Inv_Year ;
20469 bool result;
20470 PyObject * obj0 = 0 ;
20471 PyObject * obj1 = 0 ;
20472 PyObject * obj2 = 0 ;
20473 PyObject * obj3 = 0 ;
20474 char *kwnames[] = {
20475 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20476 };
20477
20478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20480 if (SWIG_arg_fail(1)) SWIG_fail;
20481 {
20482 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20483 if (SWIG_arg_fail(2)) SWIG_fail;
20484 }
20485 if (obj2) {
20486 {
20487 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20488 if (SWIG_arg_fail(3)) SWIG_fail;
20489 }
20490 }
20491 if (obj3) {
20492 {
20493 arg4 = (int)(SWIG_As_int(obj3));
20494 if (SWIG_arg_fail(4)) SWIG_fail;
20495 }
20496 }
20497 {
20498 PyThreadState* __tstate = wxPyBeginAllowThreads();
20499 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20500
20501 wxPyEndAllowThreads(__tstate);
20502 if (PyErr_Occurred()) SWIG_fail;
20503 }
20504 {
20505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20506 }
20507 return resultobj;
20508 fail:
20509 return NULL;
20510 }
20511
20512
20513 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20514 PyObject *resultobj;
20515 wxDateTime *arg1 = (wxDateTime *) 0 ;
20516 wxDateTime::WeekDay arg2 ;
20517 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20518 int arg4 = (int) wxDateTime::Inv_Year ;
20519 wxDateTime result;
20520 PyObject * obj0 = 0 ;
20521 PyObject * obj1 = 0 ;
20522 PyObject * obj2 = 0 ;
20523 PyObject * obj3 = 0 ;
20524 char *kwnames[] = {
20525 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20526 };
20527
20528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20530 if (SWIG_arg_fail(1)) SWIG_fail;
20531 {
20532 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20533 if (SWIG_arg_fail(2)) SWIG_fail;
20534 }
20535 if (obj2) {
20536 {
20537 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20538 if (SWIG_arg_fail(3)) SWIG_fail;
20539 }
20540 }
20541 if (obj3) {
20542 {
20543 arg4 = (int)(SWIG_As_int(obj3));
20544 if (SWIG_arg_fail(4)) SWIG_fail;
20545 }
20546 }
20547 {
20548 PyThreadState* __tstate = wxPyBeginAllowThreads();
20549 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20550
20551 wxPyEndAllowThreads(__tstate);
20552 if (PyErr_Occurred()) SWIG_fail;
20553 }
20554 {
20555 wxDateTime * resultptr;
20556 resultptr = new wxDateTime((wxDateTime &)(result));
20557 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20558 }
20559 return resultobj;
20560 fail:
20561 return NULL;
20562 }
20563
20564
20565 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20566 PyObject *resultobj;
20567 wxDateTime *arg1 = (wxDateTime *) 0 ;
20568 int arg2 ;
20569 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20570 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20571 bool result;
20572 PyObject * obj0 = 0 ;
20573 PyObject * obj1 = 0 ;
20574 PyObject * obj2 = 0 ;
20575 PyObject * obj3 = 0 ;
20576 char *kwnames[] = {
20577 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20578 };
20579
20580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20582 if (SWIG_arg_fail(1)) SWIG_fail;
20583 {
20584 arg2 = (int)(SWIG_As_int(obj1));
20585 if (SWIG_arg_fail(2)) SWIG_fail;
20586 }
20587 if (obj2) {
20588 {
20589 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20590 if (SWIG_arg_fail(3)) SWIG_fail;
20591 }
20592 }
20593 if (obj3) {
20594 {
20595 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20596 if (SWIG_arg_fail(4)) SWIG_fail;
20597 }
20598 }
20599 {
20600 PyThreadState* __tstate = wxPyBeginAllowThreads();
20601 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20602
20603 wxPyEndAllowThreads(__tstate);
20604 if (PyErr_Occurred()) SWIG_fail;
20605 }
20606 {
20607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20608 }
20609 return resultobj;
20610 fail:
20611 return NULL;
20612 }
20613
20614
20615 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20616 PyObject *resultobj;
20617 wxDateTime *arg1 = (wxDateTime *) 0 ;
20618 int arg2 ;
20619 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20620 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20621 wxDateTime result;
20622 PyObject * obj0 = 0 ;
20623 PyObject * obj1 = 0 ;
20624 PyObject * obj2 = 0 ;
20625 PyObject * obj3 = 0 ;
20626 char *kwnames[] = {
20627 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20628 };
20629
20630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20632 if (SWIG_arg_fail(1)) SWIG_fail;
20633 {
20634 arg2 = (int)(SWIG_As_int(obj1));
20635 if (SWIG_arg_fail(2)) SWIG_fail;
20636 }
20637 if (obj2) {
20638 {
20639 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20640 if (SWIG_arg_fail(3)) SWIG_fail;
20641 }
20642 }
20643 if (obj3) {
20644 {
20645 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20646 if (SWIG_arg_fail(4)) SWIG_fail;
20647 }
20648 }
20649 {
20650 PyThreadState* __tstate = wxPyBeginAllowThreads();
20651 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20652
20653 wxPyEndAllowThreads(__tstate);
20654 if (PyErr_Occurred()) SWIG_fail;
20655 }
20656 {
20657 wxDateTime * resultptr;
20658 resultptr = new wxDateTime((wxDateTime &)(result));
20659 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20660 }
20661 return resultobj;
20662 fail:
20663 return NULL;
20664 }
20665
20666
20667 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20668 PyObject *resultobj;
20669 int arg1 ;
20670 int arg2 ;
20671 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20672 wxDateTime result;
20673 PyObject * obj0 = 0 ;
20674 PyObject * obj1 = 0 ;
20675 PyObject * obj2 = 0 ;
20676 char *kwnames[] = {
20677 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20678 };
20679
20680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20681 {
20682 arg1 = (int)(SWIG_As_int(obj0));
20683 if (SWIG_arg_fail(1)) SWIG_fail;
20684 }
20685 {
20686 arg2 = (int)(SWIG_As_int(obj1));
20687 if (SWIG_arg_fail(2)) SWIG_fail;
20688 }
20689 if (obj2) {
20690 {
20691 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20692 if (SWIG_arg_fail(3)) SWIG_fail;
20693 }
20694 }
20695 {
20696 PyThreadState* __tstate = wxPyBeginAllowThreads();
20697 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20698
20699 wxPyEndAllowThreads(__tstate);
20700 if (PyErr_Occurred()) SWIG_fail;
20701 }
20702 {
20703 wxDateTime * resultptr;
20704 resultptr = new wxDateTime((wxDateTime &)(result));
20705 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20706 }
20707 return resultobj;
20708 fail:
20709 return NULL;
20710 }
20711
20712
20713 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20714 PyObject *resultobj;
20715 wxDateTime *arg1 = (wxDateTime *) 0 ;
20716 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20717 int arg3 = (int) wxDateTime::Inv_Year ;
20718 wxDateTime *result;
20719 PyObject * obj0 = 0 ;
20720 PyObject * obj1 = 0 ;
20721 PyObject * obj2 = 0 ;
20722 char *kwnames[] = {
20723 (char *) "self",(char *) "month",(char *) "year", NULL
20724 };
20725
20726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20728 if (SWIG_arg_fail(1)) SWIG_fail;
20729 if (obj1) {
20730 {
20731 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20732 if (SWIG_arg_fail(2)) SWIG_fail;
20733 }
20734 }
20735 if (obj2) {
20736 {
20737 arg3 = (int)(SWIG_As_int(obj2));
20738 if (SWIG_arg_fail(3)) SWIG_fail;
20739 }
20740 }
20741 {
20742 PyThreadState* __tstate = wxPyBeginAllowThreads();
20743 {
20744 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20745 result = (wxDateTime *) &_result_ref;
20746 }
20747
20748 wxPyEndAllowThreads(__tstate);
20749 if (PyErr_Occurred()) SWIG_fail;
20750 }
20751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20752 return resultobj;
20753 fail:
20754 return NULL;
20755 }
20756
20757
20758 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20759 PyObject *resultobj;
20760 wxDateTime *arg1 = (wxDateTime *) 0 ;
20761 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20762 int arg3 = (int) wxDateTime::Inv_Year ;
20763 wxDateTime result;
20764 PyObject * obj0 = 0 ;
20765 PyObject * obj1 = 0 ;
20766 PyObject * obj2 = 0 ;
20767 char *kwnames[] = {
20768 (char *) "self",(char *) "month",(char *) "year", NULL
20769 };
20770
20771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) 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 if (obj1) {
20775 {
20776 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20777 if (SWIG_arg_fail(2)) SWIG_fail;
20778 }
20779 }
20780 if (obj2) {
20781 {
20782 arg3 = (int)(SWIG_As_int(obj2));
20783 if (SWIG_arg_fail(3)) SWIG_fail;
20784 }
20785 }
20786 {
20787 PyThreadState* __tstate = wxPyBeginAllowThreads();
20788 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20789
20790 wxPyEndAllowThreads(__tstate);
20791 if (PyErr_Occurred()) SWIG_fail;
20792 }
20793 {
20794 wxDateTime * resultptr;
20795 resultptr = new wxDateTime((wxDateTime &)(result));
20796 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20797 }
20798 return resultobj;
20799 fail:
20800 return NULL;
20801 }
20802
20803
20804 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20805 PyObject *resultobj;
20806 wxDateTime *arg1 = (wxDateTime *) 0 ;
20807 int arg2 ;
20808 wxDateTime *result;
20809 PyObject * obj0 = 0 ;
20810 PyObject * obj1 = 0 ;
20811 char *kwnames[] = {
20812 (char *) "self",(char *) "yday", NULL
20813 };
20814
20815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20817 if (SWIG_arg_fail(1)) SWIG_fail;
20818 {
20819 arg2 = (int)(SWIG_As_int(obj1));
20820 if (SWIG_arg_fail(2)) SWIG_fail;
20821 }
20822 {
20823 PyThreadState* __tstate = wxPyBeginAllowThreads();
20824 {
20825 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20826 result = (wxDateTime *) &_result_ref;
20827 }
20828
20829 wxPyEndAllowThreads(__tstate);
20830 if (PyErr_Occurred()) SWIG_fail;
20831 }
20832 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20833 return resultobj;
20834 fail:
20835 return NULL;
20836 }
20837
20838
20839 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20840 PyObject *resultobj;
20841 wxDateTime *arg1 = (wxDateTime *) 0 ;
20842 int arg2 ;
20843 wxDateTime result;
20844 PyObject * obj0 = 0 ;
20845 PyObject * obj1 = 0 ;
20846 char *kwnames[] = {
20847 (char *) "self",(char *) "yday", NULL
20848 };
20849
20850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20852 if (SWIG_arg_fail(1)) SWIG_fail;
20853 {
20854 arg2 = (int)(SWIG_As_int(obj1));
20855 if (SWIG_arg_fail(2)) SWIG_fail;
20856 }
20857 {
20858 PyThreadState* __tstate = wxPyBeginAllowThreads();
20859 result = (arg1)->GetYearDay(arg2);
20860
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 {
20865 wxDateTime * resultptr;
20866 resultptr = new wxDateTime((wxDateTime &)(result));
20867 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20868 }
20869 return resultobj;
20870 fail:
20871 return NULL;
20872 }
20873
20874
20875 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20876 PyObject *resultobj;
20877 wxDateTime *arg1 = (wxDateTime *) 0 ;
20878 double result;
20879 PyObject * obj0 = 0 ;
20880 char *kwnames[] = {
20881 (char *) "self", NULL
20882 };
20883
20884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20886 if (SWIG_arg_fail(1)) SWIG_fail;
20887 {
20888 PyThreadState* __tstate = wxPyBeginAllowThreads();
20889 result = (double)(arg1)->GetJulianDayNumber();
20890
20891 wxPyEndAllowThreads(__tstate);
20892 if (PyErr_Occurred()) SWIG_fail;
20893 }
20894 {
20895 resultobj = SWIG_From_double((double)(result));
20896 }
20897 return resultobj;
20898 fail:
20899 return NULL;
20900 }
20901
20902
20903 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20904 PyObject *resultobj;
20905 wxDateTime *arg1 = (wxDateTime *) 0 ;
20906 double result;
20907 PyObject * obj0 = 0 ;
20908 char *kwnames[] = {
20909 (char *) "self", NULL
20910 };
20911
20912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
20913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20914 if (SWIG_arg_fail(1)) SWIG_fail;
20915 {
20916 PyThreadState* __tstate = wxPyBeginAllowThreads();
20917 result = (double)(arg1)->GetJDN();
20918
20919 wxPyEndAllowThreads(__tstate);
20920 if (PyErr_Occurred()) SWIG_fail;
20921 }
20922 {
20923 resultobj = SWIG_From_double((double)(result));
20924 }
20925 return resultobj;
20926 fail:
20927 return NULL;
20928 }
20929
20930
20931 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20932 PyObject *resultobj;
20933 wxDateTime *arg1 = (wxDateTime *) 0 ;
20934 double result;
20935 PyObject * obj0 = 0 ;
20936 char *kwnames[] = {
20937 (char *) "self", NULL
20938 };
20939
20940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
20941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20942 if (SWIG_arg_fail(1)) SWIG_fail;
20943 {
20944 PyThreadState* __tstate = wxPyBeginAllowThreads();
20945 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
20946
20947 wxPyEndAllowThreads(__tstate);
20948 if (PyErr_Occurred()) SWIG_fail;
20949 }
20950 {
20951 resultobj = SWIG_From_double((double)(result));
20952 }
20953 return resultobj;
20954 fail:
20955 return NULL;
20956 }
20957
20958
20959 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
20960 PyObject *resultobj;
20961 wxDateTime *arg1 = (wxDateTime *) 0 ;
20962 double result;
20963 PyObject * obj0 = 0 ;
20964 char *kwnames[] = {
20965 (char *) "self", NULL
20966 };
20967
20968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
20969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20970 if (SWIG_arg_fail(1)) SWIG_fail;
20971 {
20972 PyThreadState* __tstate = wxPyBeginAllowThreads();
20973 result = (double)(arg1)->GetMJD();
20974
20975 wxPyEndAllowThreads(__tstate);
20976 if (PyErr_Occurred()) SWIG_fail;
20977 }
20978 {
20979 resultobj = SWIG_From_double((double)(result));
20980 }
20981 return resultobj;
20982 fail:
20983 return NULL;
20984 }
20985
20986
20987 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
20988 PyObject *resultobj;
20989 wxDateTime *arg1 = (wxDateTime *) 0 ;
20990 double result;
20991 PyObject * obj0 = 0 ;
20992 char *kwnames[] = {
20993 (char *) "self", NULL
20994 };
20995
20996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
20997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20998 if (SWIG_arg_fail(1)) SWIG_fail;
20999 {
21000 PyThreadState* __tstate = wxPyBeginAllowThreads();
21001 result = (double)(arg1)->GetRataDie();
21002
21003 wxPyEndAllowThreads(__tstate);
21004 if (PyErr_Occurred()) SWIG_fail;
21005 }
21006 {
21007 resultobj = SWIG_From_double((double)(result));
21008 }
21009 return resultobj;
21010 fail:
21011 return NULL;
21012 }
21013
21014
21015 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21016 PyObject *resultobj;
21017 wxDateTime *arg1 = (wxDateTime *) 0 ;
21018 wxDateTime::TimeZone *arg2 = 0 ;
21019 bool arg3 = (bool) false ;
21020 wxDateTime result;
21021 bool temp2 = false ;
21022 PyObject * obj0 = 0 ;
21023 PyObject * obj1 = 0 ;
21024 PyObject * obj2 = 0 ;
21025 char *kwnames[] = {
21026 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21027 };
21028
21029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21031 if (SWIG_arg_fail(1)) SWIG_fail;
21032 {
21033 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21034 temp2 = true;
21035 }
21036 if (obj2) {
21037 {
21038 arg3 = (bool)(SWIG_As_bool(obj2));
21039 if (SWIG_arg_fail(3)) SWIG_fail;
21040 }
21041 }
21042 {
21043 PyThreadState* __tstate = wxPyBeginAllowThreads();
21044 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21045
21046 wxPyEndAllowThreads(__tstate);
21047 if (PyErr_Occurred()) SWIG_fail;
21048 }
21049 {
21050 wxDateTime * resultptr;
21051 resultptr = new wxDateTime((wxDateTime &)(result));
21052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21053 }
21054 {
21055 if (temp2) delete arg2;
21056 }
21057 return resultobj;
21058 fail:
21059 {
21060 if (temp2) delete arg2;
21061 }
21062 return NULL;
21063 }
21064
21065
21066 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21067 PyObject *resultobj;
21068 wxDateTime *arg1 = (wxDateTime *) 0 ;
21069 wxDateTime::TimeZone *arg2 = 0 ;
21070 bool arg3 = (bool) false ;
21071 wxDateTime *result;
21072 bool temp2 = false ;
21073 PyObject * obj0 = 0 ;
21074 PyObject * obj1 = 0 ;
21075 PyObject * obj2 = 0 ;
21076 char *kwnames[] = {
21077 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21078 };
21079
21080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21082 if (SWIG_arg_fail(1)) SWIG_fail;
21083 {
21084 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21085 temp2 = true;
21086 }
21087 if (obj2) {
21088 {
21089 arg3 = (bool)(SWIG_As_bool(obj2));
21090 if (SWIG_arg_fail(3)) SWIG_fail;
21091 }
21092 }
21093 {
21094 PyThreadState* __tstate = wxPyBeginAllowThreads();
21095 {
21096 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21097 result = (wxDateTime *) &_result_ref;
21098 }
21099
21100 wxPyEndAllowThreads(__tstate);
21101 if (PyErr_Occurred()) SWIG_fail;
21102 }
21103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21104 {
21105 if (temp2) delete arg2;
21106 }
21107 return resultobj;
21108 fail:
21109 {
21110 if (temp2) delete arg2;
21111 }
21112 return NULL;
21113 }
21114
21115
21116 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21117 PyObject *resultobj;
21118 wxDateTime *arg1 = (wxDateTime *) 0 ;
21119 bool arg2 = (bool) false ;
21120 wxDateTime result;
21121 PyObject * obj0 = 0 ;
21122 PyObject * obj1 = 0 ;
21123 char *kwnames[] = {
21124 (char *) "self",(char *) "noDST", NULL
21125 };
21126
21127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21129 if (SWIG_arg_fail(1)) SWIG_fail;
21130 if (obj1) {
21131 {
21132 arg2 = (bool)(SWIG_As_bool(obj1));
21133 if (SWIG_arg_fail(2)) SWIG_fail;
21134 }
21135 }
21136 {
21137 PyThreadState* __tstate = wxPyBeginAllowThreads();
21138 result = (arg1)->ToGMT(arg2);
21139
21140 wxPyEndAllowThreads(__tstate);
21141 if (PyErr_Occurred()) SWIG_fail;
21142 }
21143 {
21144 wxDateTime * resultptr;
21145 resultptr = new wxDateTime((wxDateTime &)(result));
21146 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21147 }
21148 return resultobj;
21149 fail:
21150 return NULL;
21151 }
21152
21153
21154 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21155 PyObject *resultobj;
21156 wxDateTime *arg1 = (wxDateTime *) 0 ;
21157 bool arg2 = (bool) false ;
21158 wxDateTime *result;
21159 PyObject * obj0 = 0 ;
21160 PyObject * obj1 = 0 ;
21161 char *kwnames[] = {
21162 (char *) "self",(char *) "noDST", NULL
21163 };
21164
21165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21167 if (SWIG_arg_fail(1)) SWIG_fail;
21168 if (obj1) {
21169 {
21170 arg2 = (bool)(SWIG_As_bool(obj1));
21171 if (SWIG_arg_fail(2)) SWIG_fail;
21172 }
21173 }
21174 {
21175 PyThreadState* __tstate = wxPyBeginAllowThreads();
21176 {
21177 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21178 result = (wxDateTime *) &_result_ref;
21179 }
21180
21181 wxPyEndAllowThreads(__tstate);
21182 if (PyErr_Occurred()) SWIG_fail;
21183 }
21184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21185 return resultobj;
21186 fail:
21187 return NULL;
21188 }
21189
21190
21191 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21192 PyObject *resultobj;
21193 wxDateTime *arg1 = (wxDateTime *) 0 ;
21194 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21195 int result;
21196 PyObject * obj0 = 0 ;
21197 PyObject * obj1 = 0 ;
21198 char *kwnames[] = {
21199 (char *) "self",(char *) "country", NULL
21200 };
21201
21202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21204 if (SWIG_arg_fail(1)) SWIG_fail;
21205 if (obj1) {
21206 {
21207 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21208 if (SWIG_arg_fail(2)) SWIG_fail;
21209 }
21210 }
21211 {
21212 PyThreadState* __tstate = wxPyBeginAllowThreads();
21213 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21214
21215 wxPyEndAllowThreads(__tstate);
21216 if (PyErr_Occurred()) SWIG_fail;
21217 }
21218 {
21219 resultobj = SWIG_From_int((int)(result));
21220 }
21221 return resultobj;
21222 fail:
21223 return NULL;
21224 }
21225
21226
21227 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21228 PyObject *resultobj;
21229 wxDateTime *arg1 = (wxDateTime *) 0 ;
21230 bool result;
21231 PyObject * obj0 = 0 ;
21232 char *kwnames[] = {
21233 (char *) "self", NULL
21234 };
21235
21236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21238 if (SWIG_arg_fail(1)) SWIG_fail;
21239 {
21240 PyThreadState* __tstate = wxPyBeginAllowThreads();
21241 result = (bool)((wxDateTime const *)arg1)->IsValid();
21242
21243 wxPyEndAllowThreads(__tstate);
21244 if (PyErr_Occurred()) SWIG_fail;
21245 }
21246 {
21247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21248 }
21249 return resultobj;
21250 fail:
21251 return NULL;
21252 }
21253
21254
21255 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21256 PyObject *resultobj;
21257 wxDateTime *arg1 = (wxDateTime *) 0 ;
21258 time_t result;
21259 PyObject * obj0 = 0 ;
21260 char *kwnames[] = {
21261 (char *) "self", NULL
21262 };
21263
21264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21266 if (SWIG_arg_fail(1)) SWIG_fail;
21267 {
21268 PyThreadState* __tstate = wxPyBeginAllowThreads();
21269 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21270
21271 wxPyEndAllowThreads(__tstate);
21272 if (PyErr_Occurred()) SWIG_fail;
21273 }
21274 {
21275 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21276 }
21277 return resultobj;
21278 fail:
21279 return NULL;
21280 }
21281
21282
21283 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21284 PyObject *resultobj;
21285 wxDateTime *arg1 = (wxDateTime *) 0 ;
21286 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21287 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21288 int result;
21289 bool temp2 = false ;
21290 PyObject * obj0 = 0 ;
21291 PyObject * obj1 = 0 ;
21292 char *kwnames[] = {
21293 (char *) "self",(char *) "tz", NULL
21294 };
21295
21296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21298 if (SWIG_arg_fail(1)) SWIG_fail;
21299 if (obj1) {
21300 {
21301 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21302 temp2 = true;
21303 }
21304 }
21305 {
21306 PyThreadState* __tstate = wxPyBeginAllowThreads();
21307 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21308
21309 wxPyEndAllowThreads(__tstate);
21310 if (PyErr_Occurred()) SWIG_fail;
21311 }
21312 {
21313 resultobj = SWIG_From_int((int)(result));
21314 }
21315 {
21316 if (temp2) delete arg2;
21317 }
21318 return resultobj;
21319 fail:
21320 {
21321 if (temp2) delete arg2;
21322 }
21323 return NULL;
21324 }
21325
21326
21327 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21328 PyObject *resultobj;
21329 wxDateTime *arg1 = (wxDateTime *) 0 ;
21330 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21331 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21332 wxDateTime::Month result;
21333 bool temp2 = false ;
21334 PyObject * obj0 = 0 ;
21335 PyObject * obj1 = 0 ;
21336 char *kwnames[] = {
21337 (char *) "self",(char *) "tz", NULL
21338 };
21339
21340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21342 if (SWIG_arg_fail(1)) SWIG_fail;
21343 if (obj1) {
21344 {
21345 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21346 temp2 = true;
21347 }
21348 }
21349 {
21350 PyThreadState* __tstate = wxPyBeginAllowThreads();
21351 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21352
21353 wxPyEndAllowThreads(__tstate);
21354 if (PyErr_Occurred()) SWIG_fail;
21355 }
21356 resultobj = SWIG_From_int((result));
21357 {
21358 if (temp2) delete arg2;
21359 }
21360 return resultobj;
21361 fail:
21362 {
21363 if (temp2) delete arg2;
21364 }
21365 return NULL;
21366 }
21367
21368
21369 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21370 PyObject *resultobj;
21371 wxDateTime *arg1 = (wxDateTime *) 0 ;
21372 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21373 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21374 int result;
21375 bool temp2 = false ;
21376 PyObject * obj0 = 0 ;
21377 PyObject * obj1 = 0 ;
21378 char *kwnames[] = {
21379 (char *) "self",(char *) "tz", NULL
21380 };
21381
21382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21384 if (SWIG_arg_fail(1)) SWIG_fail;
21385 if (obj1) {
21386 {
21387 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21388 temp2 = true;
21389 }
21390 }
21391 {
21392 PyThreadState* __tstate = wxPyBeginAllowThreads();
21393 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21394
21395 wxPyEndAllowThreads(__tstate);
21396 if (PyErr_Occurred()) SWIG_fail;
21397 }
21398 {
21399 resultobj = SWIG_From_int((int)(result));
21400 }
21401 {
21402 if (temp2) delete arg2;
21403 }
21404 return resultobj;
21405 fail:
21406 {
21407 if (temp2) delete arg2;
21408 }
21409 return NULL;
21410 }
21411
21412
21413 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21414 PyObject *resultobj;
21415 wxDateTime *arg1 = (wxDateTime *) 0 ;
21416 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21417 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21418 wxDateTime::WeekDay result;
21419 bool temp2 = false ;
21420 PyObject * obj0 = 0 ;
21421 PyObject * obj1 = 0 ;
21422 char *kwnames[] = {
21423 (char *) "self",(char *) "tz", NULL
21424 };
21425
21426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21428 if (SWIG_arg_fail(1)) SWIG_fail;
21429 if (obj1) {
21430 {
21431 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21432 temp2 = true;
21433 }
21434 }
21435 {
21436 PyThreadState* __tstate = wxPyBeginAllowThreads();
21437 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21438
21439 wxPyEndAllowThreads(__tstate);
21440 if (PyErr_Occurred()) SWIG_fail;
21441 }
21442 resultobj = SWIG_From_int((result));
21443 {
21444 if (temp2) delete arg2;
21445 }
21446 return resultobj;
21447 fail:
21448 {
21449 if (temp2) delete arg2;
21450 }
21451 return NULL;
21452 }
21453
21454
21455 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21456 PyObject *resultobj;
21457 wxDateTime *arg1 = (wxDateTime *) 0 ;
21458 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21459 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21460 int result;
21461 bool temp2 = false ;
21462 PyObject * obj0 = 0 ;
21463 PyObject * obj1 = 0 ;
21464 char *kwnames[] = {
21465 (char *) "self",(char *) "tz", NULL
21466 };
21467
21468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21470 if (SWIG_arg_fail(1)) SWIG_fail;
21471 if (obj1) {
21472 {
21473 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21474 temp2 = true;
21475 }
21476 }
21477 {
21478 PyThreadState* __tstate = wxPyBeginAllowThreads();
21479 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21480
21481 wxPyEndAllowThreads(__tstate);
21482 if (PyErr_Occurred()) SWIG_fail;
21483 }
21484 {
21485 resultobj = SWIG_From_int((int)(result));
21486 }
21487 {
21488 if (temp2) delete arg2;
21489 }
21490 return resultobj;
21491 fail:
21492 {
21493 if (temp2) delete arg2;
21494 }
21495 return NULL;
21496 }
21497
21498
21499 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21500 PyObject *resultobj;
21501 wxDateTime *arg1 = (wxDateTime *) 0 ;
21502 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21503 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21504 int result;
21505 bool temp2 = false ;
21506 PyObject * obj0 = 0 ;
21507 PyObject * obj1 = 0 ;
21508 char *kwnames[] = {
21509 (char *) "self",(char *) "tz", NULL
21510 };
21511
21512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21514 if (SWIG_arg_fail(1)) SWIG_fail;
21515 if (obj1) {
21516 {
21517 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21518 temp2 = true;
21519 }
21520 }
21521 {
21522 PyThreadState* __tstate = wxPyBeginAllowThreads();
21523 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21524
21525 wxPyEndAllowThreads(__tstate);
21526 if (PyErr_Occurred()) SWIG_fail;
21527 }
21528 {
21529 resultobj = SWIG_From_int((int)(result));
21530 }
21531 {
21532 if (temp2) delete arg2;
21533 }
21534 return resultobj;
21535 fail:
21536 {
21537 if (temp2) delete arg2;
21538 }
21539 return NULL;
21540 }
21541
21542
21543 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21544 PyObject *resultobj;
21545 wxDateTime *arg1 = (wxDateTime *) 0 ;
21546 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21547 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21548 int result;
21549 bool temp2 = false ;
21550 PyObject * obj0 = 0 ;
21551 PyObject * obj1 = 0 ;
21552 char *kwnames[] = {
21553 (char *) "self",(char *) "tz", NULL
21554 };
21555
21556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21558 if (SWIG_arg_fail(1)) SWIG_fail;
21559 if (obj1) {
21560 {
21561 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21562 temp2 = true;
21563 }
21564 }
21565 {
21566 PyThreadState* __tstate = wxPyBeginAllowThreads();
21567 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21568
21569 wxPyEndAllowThreads(__tstate);
21570 if (PyErr_Occurred()) SWIG_fail;
21571 }
21572 {
21573 resultobj = SWIG_From_int((int)(result));
21574 }
21575 {
21576 if (temp2) delete arg2;
21577 }
21578 return resultobj;
21579 fail:
21580 {
21581 if (temp2) delete arg2;
21582 }
21583 return NULL;
21584 }
21585
21586
21587 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21588 PyObject *resultobj;
21589 wxDateTime *arg1 = (wxDateTime *) 0 ;
21590 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21591 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21592 int result;
21593 bool temp2 = false ;
21594 PyObject * obj0 = 0 ;
21595 PyObject * obj1 = 0 ;
21596 char *kwnames[] = {
21597 (char *) "self",(char *) "tz", NULL
21598 };
21599
21600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21602 if (SWIG_arg_fail(1)) SWIG_fail;
21603 if (obj1) {
21604 {
21605 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21606 temp2 = true;
21607 }
21608 }
21609 {
21610 PyThreadState* __tstate = wxPyBeginAllowThreads();
21611 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21612
21613 wxPyEndAllowThreads(__tstate);
21614 if (PyErr_Occurred()) SWIG_fail;
21615 }
21616 {
21617 resultobj = SWIG_From_int((int)(result));
21618 }
21619 {
21620 if (temp2) delete arg2;
21621 }
21622 return resultobj;
21623 fail:
21624 {
21625 if (temp2) delete arg2;
21626 }
21627 return NULL;
21628 }
21629
21630
21631 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21632 PyObject *resultobj;
21633 wxDateTime *arg1 = (wxDateTime *) 0 ;
21634 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21635 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21636 int result;
21637 bool temp2 = false ;
21638 PyObject * obj0 = 0 ;
21639 PyObject * obj1 = 0 ;
21640 char *kwnames[] = {
21641 (char *) "self",(char *) "tz", NULL
21642 };
21643
21644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21646 if (SWIG_arg_fail(1)) SWIG_fail;
21647 if (obj1) {
21648 {
21649 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21650 temp2 = true;
21651 }
21652 }
21653 {
21654 PyThreadState* __tstate = wxPyBeginAllowThreads();
21655 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21656
21657 wxPyEndAllowThreads(__tstate);
21658 if (PyErr_Occurred()) SWIG_fail;
21659 }
21660 {
21661 resultobj = SWIG_From_int((int)(result));
21662 }
21663 {
21664 if (temp2) delete arg2;
21665 }
21666 return resultobj;
21667 fail:
21668 {
21669 if (temp2) delete arg2;
21670 }
21671 return NULL;
21672 }
21673
21674
21675 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21676 PyObject *resultobj;
21677 wxDateTime *arg1 = (wxDateTime *) 0 ;
21678 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21679 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21680 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21681 int result;
21682 bool temp3 = false ;
21683 PyObject * obj0 = 0 ;
21684 PyObject * obj1 = 0 ;
21685 PyObject * obj2 = 0 ;
21686 char *kwnames[] = {
21687 (char *) "self",(char *) "flags",(char *) "tz", NULL
21688 };
21689
21690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21692 if (SWIG_arg_fail(1)) SWIG_fail;
21693 if (obj1) {
21694 {
21695 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21696 if (SWIG_arg_fail(2)) SWIG_fail;
21697 }
21698 }
21699 if (obj2) {
21700 {
21701 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21702 temp3 = true;
21703 }
21704 }
21705 {
21706 PyThreadState* __tstate = wxPyBeginAllowThreads();
21707 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21708
21709 wxPyEndAllowThreads(__tstate);
21710 if (PyErr_Occurred()) SWIG_fail;
21711 }
21712 {
21713 resultobj = SWIG_From_int((int)(result));
21714 }
21715 {
21716 if (temp3) delete arg3;
21717 }
21718 return resultobj;
21719 fail:
21720 {
21721 if (temp3) delete arg3;
21722 }
21723 return NULL;
21724 }
21725
21726
21727 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21728 PyObject *resultobj;
21729 wxDateTime *arg1 = (wxDateTime *) 0 ;
21730 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21731 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21732 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21733 int result;
21734 bool temp3 = false ;
21735 PyObject * obj0 = 0 ;
21736 PyObject * obj1 = 0 ;
21737 PyObject * obj2 = 0 ;
21738 char *kwnames[] = {
21739 (char *) "self",(char *) "flags",(char *) "tz", NULL
21740 };
21741
21742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21744 if (SWIG_arg_fail(1)) SWIG_fail;
21745 if (obj1) {
21746 {
21747 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21748 if (SWIG_arg_fail(2)) SWIG_fail;
21749 }
21750 }
21751 if (obj2) {
21752 {
21753 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21754 temp3 = true;
21755 }
21756 }
21757 {
21758 PyThreadState* __tstate = wxPyBeginAllowThreads();
21759 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21760
21761 wxPyEndAllowThreads(__tstate);
21762 if (PyErr_Occurred()) SWIG_fail;
21763 }
21764 {
21765 resultobj = SWIG_From_int((int)(result));
21766 }
21767 {
21768 if (temp3) delete arg3;
21769 }
21770 return resultobj;
21771 fail:
21772 {
21773 if (temp3) delete arg3;
21774 }
21775 return NULL;
21776 }
21777
21778
21779 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21780 PyObject *resultobj;
21781 wxDateTime *arg1 = (wxDateTime *) 0 ;
21782 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21783 bool result;
21784 PyObject * obj0 = 0 ;
21785 PyObject * obj1 = 0 ;
21786 char *kwnames[] = {
21787 (char *) "self",(char *) "country", NULL
21788 };
21789
21790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21792 if (SWIG_arg_fail(1)) SWIG_fail;
21793 if (obj1) {
21794 {
21795 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21796 if (SWIG_arg_fail(2)) SWIG_fail;
21797 }
21798 }
21799 {
21800 PyThreadState* __tstate = wxPyBeginAllowThreads();
21801 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21802
21803 wxPyEndAllowThreads(__tstate);
21804 if (PyErr_Occurred()) SWIG_fail;
21805 }
21806 {
21807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21808 }
21809 return resultobj;
21810 fail:
21811 return NULL;
21812 }
21813
21814
21815 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21816 PyObject *resultobj;
21817 wxDateTime *arg1 = (wxDateTime *) 0 ;
21818 wxDateTime *arg2 = 0 ;
21819 bool result;
21820 PyObject * obj0 = 0 ;
21821 PyObject * obj1 = 0 ;
21822 char *kwnames[] = {
21823 (char *) "self",(char *) "datetime", NULL
21824 };
21825
21826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21828 if (SWIG_arg_fail(1)) SWIG_fail;
21829 {
21830 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21831 if (SWIG_arg_fail(2)) SWIG_fail;
21832 if (arg2 == NULL) {
21833 SWIG_null_ref("wxDateTime");
21834 }
21835 if (SWIG_arg_fail(2)) SWIG_fail;
21836 }
21837 {
21838 PyThreadState* __tstate = wxPyBeginAllowThreads();
21839 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21840
21841 wxPyEndAllowThreads(__tstate);
21842 if (PyErr_Occurred()) SWIG_fail;
21843 }
21844 {
21845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21846 }
21847 return resultobj;
21848 fail:
21849 return NULL;
21850 }
21851
21852
21853 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21854 PyObject *resultobj;
21855 wxDateTime *arg1 = (wxDateTime *) 0 ;
21856 wxDateTime *arg2 = 0 ;
21857 bool result;
21858 PyObject * obj0 = 0 ;
21859 PyObject * obj1 = 0 ;
21860 char *kwnames[] = {
21861 (char *) "self",(char *) "datetime", NULL
21862 };
21863
21864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21866 if (SWIG_arg_fail(1)) SWIG_fail;
21867 {
21868 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21869 if (SWIG_arg_fail(2)) SWIG_fail;
21870 if (arg2 == NULL) {
21871 SWIG_null_ref("wxDateTime");
21872 }
21873 if (SWIG_arg_fail(2)) SWIG_fail;
21874 }
21875 {
21876 PyThreadState* __tstate = wxPyBeginAllowThreads();
21877 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21878
21879 wxPyEndAllowThreads(__tstate);
21880 if (PyErr_Occurred()) SWIG_fail;
21881 }
21882 {
21883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21884 }
21885 return resultobj;
21886 fail:
21887 return NULL;
21888 }
21889
21890
21891 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
21892 PyObject *resultobj;
21893 wxDateTime *arg1 = (wxDateTime *) 0 ;
21894 wxDateTime *arg2 = 0 ;
21895 bool result;
21896 PyObject * obj0 = 0 ;
21897 PyObject * obj1 = 0 ;
21898 char *kwnames[] = {
21899 (char *) "self",(char *) "datetime", NULL
21900 };
21901
21902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
21903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21904 if (SWIG_arg_fail(1)) SWIG_fail;
21905 {
21906 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21907 if (SWIG_arg_fail(2)) SWIG_fail;
21908 if (arg2 == NULL) {
21909 SWIG_null_ref("wxDateTime");
21910 }
21911 if (SWIG_arg_fail(2)) SWIG_fail;
21912 }
21913 {
21914 PyThreadState* __tstate = wxPyBeginAllowThreads();
21915 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
21916
21917 wxPyEndAllowThreads(__tstate);
21918 if (PyErr_Occurred()) SWIG_fail;
21919 }
21920 {
21921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21922 }
21923 return resultobj;
21924 fail:
21925 return NULL;
21926 }
21927
21928
21929 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21930 PyObject *resultobj;
21931 wxDateTime *arg1 = (wxDateTime *) 0 ;
21932 wxDateTime *arg2 = 0 ;
21933 wxDateTime *arg3 = 0 ;
21934 bool result;
21935 PyObject * obj0 = 0 ;
21936 PyObject * obj1 = 0 ;
21937 PyObject * obj2 = 0 ;
21938 char *kwnames[] = {
21939 (char *) "self",(char *) "t1",(char *) "t2", NULL
21940 };
21941
21942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21944 if (SWIG_arg_fail(1)) SWIG_fail;
21945 {
21946 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21947 if (SWIG_arg_fail(2)) SWIG_fail;
21948 if (arg2 == NULL) {
21949 SWIG_null_ref("wxDateTime");
21950 }
21951 if (SWIG_arg_fail(2)) SWIG_fail;
21952 }
21953 {
21954 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21955 if (SWIG_arg_fail(3)) SWIG_fail;
21956 if (arg3 == NULL) {
21957 SWIG_null_ref("wxDateTime");
21958 }
21959 if (SWIG_arg_fail(3)) SWIG_fail;
21960 }
21961 {
21962 PyThreadState* __tstate = wxPyBeginAllowThreads();
21963 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21964
21965 wxPyEndAllowThreads(__tstate);
21966 if (PyErr_Occurred()) SWIG_fail;
21967 }
21968 {
21969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21970 }
21971 return resultobj;
21972 fail:
21973 return NULL;
21974 }
21975
21976
21977 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21978 PyObject *resultobj;
21979 wxDateTime *arg1 = (wxDateTime *) 0 ;
21980 wxDateTime *arg2 = 0 ;
21981 wxDateTime *arg3 = 0 ;
21982 bool result;
21983 PyObject * obj0 = 0 ;
21984 PyObject * obj1 = 0 ;
21985 PyObject * obj2 = 0 ;
21986 char *kwnames[] = {
21987 (char *) "self",(char *) "t1",(char *) "t2", NULL
21988 };
21989
21990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21992 if (SWIG_arg_fail(1)) SWIG_fail;
21993 {
21994 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21995 if (SWIG_arg_fail(2)) SWIG_fail;
21996 if (arg2 == NULL) {
21997 SWIG_null_ref("wxDateTime");
21998 }
21999 if (SWIG_arg_fail(2)) SWIG_fail;
22000 }
22001 {
22002 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22003 if (SWIG_arg_fail(3)) SWIG_fail;
22004 if (arg3 == NULL) {
22005 SWIG_null_ref("wxDateTime");
22006 }
22007 if (SWIG_arg_fail(3)) SWIG_fail;
22008 }
22009 {
22010 PyThreadState* __tstate = wxPyBeginAllowThreads();
22011 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22012
22013 wxPyEndAllowThreads(__tstate);
22014 if (PyErr_Occurred()) SWIG_fail;
22015 }
22016 {
22017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22018 }
22019 return resultobj;
22020 fail:
22021 return NULL;
22022 }
22023
22024
22025 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22026 PyObject *resultobj;
22027 wxDateTime *arg1 = (wxDateTime *) 0 ;
22028 wxDateTime *arg2 = 0 ;
22029 bool result;
22030 PyObject * obj0 = 0 ;
22031 PyObject * obj1 = 0 ;
22032 char *kwnames[] = {
22033 (char *) "self",(char *) "dt", NULL
22034 };
22035
22036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22038 if (SWIG_arg_fail(1)) SWIG_fail;
22039 {
22040 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22041 if (SWIG_arg_fail(2)) SWIG_fail;
22042 if (arg2 == NULL) {
22043 SWIG_null_ref("wxDateTime");
22044 }
22045 if (SWIG_arg_fail(2)) SWIG_fail;
22046 }
22047 {
22048 PyThreadState* __tstate = wxPyBeginAllowThreads();
22049 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22050
22051 wxPyEndAllowThreads(__tstate);
22052 if (PyErr_Occurred()) SWIG_fail;
22053 }
22054 {
22055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22056 }
22057 return resultobj;
22058 fail:
22059 return NULL;
22060 }
22061
22062
22063 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22064 PyObject *resultobj;
22065 wxDateTime *arg1 = (wxDateTime *) 0 ;
22066 wxDateTime *arg2 = 0 ;
22067 bool result;
22068 PyObject * obj0 = 0 ;
22069 PyObject * obj1 = 0 ;
22070 char *kwnames[] = {
22071 (char *) "self",(char *) "dt", NULL
22072 };
22073
22074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22076 if (SWIG_arg_fail(1)) SWIG_fail;
22077 {
22078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22079 if (SWIG_arg_fail(2)) SWIG_fail;
22080 if (arg2 == NULL) {
22081 SWIG_null_ref("wxDateTime");
22082 }
22083 if (SWIG_arg_fail(2)) SWIG_fail;
22084 }
22085 {
22086 PyThreadState* __tstate = wxPyBeginAllowThreads();
22087 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22088
22089 wxPyEndAllowThreads(__tstate);
22090 if (PyErr_Occurred()) SWIG_fail;
22091 }
22092 {
22093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22094 }
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22102 PyObject *resultobj;
22103 wxDateTime *arg1 = (wxDateTime *) 0 ;
22104 wxDateTime *arg2 = 0 ;
22105 wxTimeSpan *arg3 = 0 ;
22106 bool result;
22107 PyObject * obj0 = 0 ;
22108 PyObject * obj1 = 0 ;
22109 PyObject * obj2 = 0 ;
22110 char *kwnames[] = {
22111 (char *) "self",(char *) "dt",(char *) "ts", NULL
22112 };
22113
22114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22116 if (SWIG_arg_fail(1)) SWIG_fail;
22117 {
22118 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22119 if (SWIG_arg_fail(2)) SWIG_fail;
22120 if (arg2 == NULL) {
22121 SWIG_null_ref("wxDateTime");
22122 }
22123 if (SWIG_arg_fail(2)) SWIG_fail;
22124 }
22125 {
22126 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22127 if (SWIG_arg_fail(3)) SWIG_fail;
22128 if (arg3 == NULL) {
22129 SWIG_null_ref("wxTimeSpan");
22130 }
22131 if (SWIG_arg_fail(3)) SWIG_fail;
22132 }
22133 {
22134 PyThreadState* __tstate = wxPyBeginAllowThreads();
22135 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22136
22137 wxPyEndAllowThreads(__tstate);
22138 if (PyErr_Occurred()) SWIG_fail;
22139 }
22140 {
22141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22142 }
22143 return resultobj;
22144 fail:
22145 return NULL;
22146 }
22147
22148
22149 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22150 PyObject *resultobj;
22151 wxDateTime *arg1 = (wxDateTime *) 0 ;
22152 wxTimeSpan *arg2 = 0 ;
22153 wxDateTime *result;
22154 PyObject * obj0 = 0 ;
22155 PyObject * obj1 = 0 ;
22156 char *kwnames[] = {
22157 (char *) "self",(char *) "diff", NULL
22158 };
22159
22160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22162 if (SWIG_arg_fail(1)) SWIG_fail;
22163 {
22164 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22165 if (SWIG_arg_fail(2)) SWIG_fail;
22166 if (arg2 == NULL) {
22167 SWIG_null_ref("wxTimeSpan");
22168 }
22169 if (SWIG_arg_fail(2)) SWIG_fail;
22170 }
22171 {
22172 PyThreadState* __tstate = wxPyBeginAllowThreads();
22173 {
22174 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22175 result = (wxDateTime *) &_result_ref;
22176 }
22177
22178 wxPyEndAllowThreads(__tstate);
22179 if (PyErr_Occurred()) SWIG_fail;
22180 }
22181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22182 return resultobj;
22183 fail:
22184 return NULL;
22185 }
22186
22187
22188 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22189 PyObject *resultobj;
22190 wxDateTime *arg1 = (wxDateTime *) 0 ;
22191 wxDateSpan *arg2 = 0 ;
22192 wxDateTime *result;
22193 PyObject * obj0 = 0 ;
22194 PyObject * obj1 = 0 ;
22195 char *kwnames[] = {
22196 (char *) "self",(char *) "diff", NULL
22197 };
22198
22199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22201 if (SWIG_arg_fail(1)) SWIG_fail;
22202 {
22203 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22204 if (SWIG_arg_fail(2)) SWIG_fail;
22205 if (arg2 == NULL) {
22206 SWIG_null_ref("wxDateSpan");
22207 }
22208 if (SWIG_arg_fail(2)) SWIG_fail;
22209 }
22210 {
22211 PyThreadState* __tstate = wxPyBeginAllowThreads();
22212 {
22213 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22214 result = (wxDateTime *) &_result_ref;
22215 }
22216
22217 wxPyEndAllowThreads(__tstate);
22218 if (PyErr_Occurred()) SWIG_fail;
22219 }
22220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22221 return resultobj;
22222 fail:
22223 return NULL;
22224 }
22225
22226
22227 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22228 PyObject *resultobj;
22229 wxDateTime *arg1 = (wxDateTime *) 0 ;
22230 wxTimeSpan *arg2 = 0 ;
22231 wxDateTime *result;
22232 PyObject * obj0 = 0 ;
22233 PyObject * obj1 = 0 ;
22234 char *kwnames[] = {
22235 (char *) "self",(char *) "diff", NULL
22236 };
22237
22238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22240 if (SWIG_arg_fail(1)) SWIG_fail;
22241 {
22242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22243 if (SWIG_arg_fail(2)) SWIG_fail;
22244 if (arg2 == NULL) {
22245 SWIG_null_ref("wxTimeSpan");
22246 }
22247 if (SWIG_arg_fail(2)) SWIG_fail;
22248 }
22249 {
22250 PyThreadState* __tstate = wxPyBeginAllowThreads();
22251 {
22252 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22253 result = (wxDateTime *) &_result_ref;
22254 }
22255
22256 wxPyEndAllowThreads(__tstate);
22257 if (PyErr_Occurred()) SWIG_fail;
22258 }
22259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22260 return resultobj;
22261 fail:
22262 return NULL;
22263 }
22264
22265
22266 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22267 PyObject *resultobj;
22268 wxDateTime *arg1 = (wxDateTime *) 0 ;
22269 wxDateSpan *arg2 = 0 ;
22270 wxDateTime *result;
22271 PyObject * obj0 = 0 ;
22272 PyObject * obj1 = 0 ;
22273 char *kwnames[] = {
22274 (char *) "self",(char *) "diff", NULL
22275 };
22276
22277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22279 if (SWIG_arg_fail(1)) SWIG_fail;
22280 {
22281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22282 if (SWIG_arg_fail(2)) SWIG_fail;
22283 if (arg2 == NULL) {
22284 SWIG_null_ref("wxDateSpan");
22285 }
22286 if (SWIG_arg_fail(2)) SWIG_fail;
22287 }
22288 {
22289 PyThreadState* __tstate = wxPyBeginAllowThreads();
22290 {
22291 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22292 result = (wxDateTime *) &_result_ref;
22293 }
22294
22295 wxPyEndAllowThreads(__tstate);
22296 if (PyErr_Occurred()) SWIG_fail;
22297 }
22298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22299 return resultobj;
22300 fail:
22301 return NULL;
22302 }
22303
22304
22305 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22306 PyObject *resultobj;
22307 wxDateTime *arg1 = (wxDateTime *) 0 ;
22308 wxDateTime *arg2 = 0 ;
22309 wxTimeSpan result;
22310 PyObject * obj0 = 0 ;
22311 PyObject * obj1 = 0 ;
22312 char *kwnames[] = {
22313 (char *) "self",(char *) "dt", NULL
22314 };
22315
22316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22318 if (SWIG_arg_fail(1)) SWIG_fail;
22319 {
22320 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22321 if (SWIG_arg_fail(2)) SWIG_fail;
22322 if (arg2 == NULL) {
22323 SWIG_null_ref("wxDateTime");
22324 }
22325 if (SWIG_arg_fail(2)) SWIG_fail;
22326 }
22327 {
22328 PyThreadState* __tstate = wxPyBeginAllowThreads();
22329 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22330
22331 wxPyEndAllowThreads(__tstate);
22332 if (PyErr_Occurred()) SWIG_fail;
22333 }
22334 {
22335 wxTimeSpan * resultptr;
22336 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22337 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22338 }
22339 return resultobj;
22340 fail:
22341 return NULL;
22342 }
22343
22344
22345 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22346 PyObject *resultobj;
22347 wxDateTime *arg1 = (wxDateTime *) 0 ;
22348 wxTimeSpan *arg2 = 0 ;
22349 wxDateTime *result;
22350 PyObject * obj0 = 0 ;
22351 PyObject * obj1 = 0 ;
22352
22353 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22355 if (SWIG_arg_fail(1)) SWIG_fail;
22356 {
22357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22358 if (SWIG_arg_fail(2)) SWIG_fail;
22359 if (arg2 == NULL) {
22360 SWIG_null_ref("wxTimeSpan");
22361 }
22362 if (SWIG_arg_fail(2)) SWIG_fail;
22363 }
22364 {
22365 PyThreadState* __tstate = wxPyBeginAllowThreads();
22366 {
22367 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22368 result = (wxDateTime *) &_result_ref;
22369 }
22370
22371 wxPyEndAllowThreads(__tstate);
22372 if (PyErr_Occurred()) SWIG_fail;
22373 }
22374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22375 return resultobj;
22376 fail:
22377 return NULL;
22378 }
22379
22380
22381 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22382 PyObject *resultobj;
22383 wxDateTime *arg1 = (wxDateTime *) 0 ;
22384 wxDateSpan *arg2 = 0 ;
22385 wxDateTime *result;
22386 PyObject * obj0 = 0 ;
22387 PyObject * obj1 = 0 ;
22388
22389 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22391 if (SWIG_arg_fail(1)) SWIG_fail;
22392 {
22393 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22394 if (SWIG_arg_fail(2)) SWIG_fail;
22395 if (arg2 == NULL) {
22396 SWIG_null_ref("wxDateSpan");
22397 }
22398 if (SWIG_arg_fail(2)) SWIG_fail;
22399 }
22400 {
22401 PyThreadState* __tstate = wxPyBeginAllowThreads();
22402 {
22403 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22404 result = (wxDateTime *) &_result_ref;
22405 }
22406
22407 wxPyEndAllowThreads(__tstate);
22408 if (PyErr_Occurred()) SWIG_fail;
22409 }
22410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22411 return resultobj;
22412 fail:
22413 return NULL;
22414 }
22415
22416
22417 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22418 int argc;
22419 PyObject *argv[3];
22420 int ii;
22421
22422 argc = PyObject_Length(args);
22423 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22424 argv[ii] = PyTuple_GetItem(args,ii);
22425 }
22426 if (argc == 2) {
22427 int _v;
22428 {
22429 void *ptr;
22430 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22431 _v = 0;
22432 PyErr_Clear();
22433 } else {
22434 _v = 1;
22435 }
22436 }
22437 if (_v) {
22438 {
22439 void *ptr = 0;
22440 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22441 _v = 0;
22442 PyErr_Clear();
22443 } else {
22444 _v = (ptr != 0);
22445 }
22446 }
22447 if (_v) {
22448 return _wrap_DateTime___iadd____SWIG_0(self,args);
22449 }
22450 }
22451 }
22452 if (argc == 2) {
22453 int _v;
22454 {
22455 void *ptr;
22456 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22457 _v = 0;
22458 PyErr_Clear();
22459 } else {
22460 _v = 1;
22461 }
22462 }
22463 if (_v) {
22464 {
22465 void *ptr = 0;
22466 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22467 _v = 0;
22468 PyErr_Clear();
22469 } else {
22470 _v = (ptr != 0);
22471 }
22472 }
22473 if (_v) {
22474 return _wrap_DateTime___iadd____SWIG_1(self,args);
22475 }
22476 }
22477 }
22478
22479 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22480 return NULL;
22481 }
22482
22483
22484 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22485 PyObject *resultobj;
22486 wxDateTime *arg1 = (wxDateTime *) 0 ;
22487 wxTimeSpan *arg2 = 0 ;
22488 wxDateTime *result;
22489 PyObject * obj0 = 0 ;
22490 PyObject * obj1 = 0 ;
22491
22492 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22494 if (SWIG_arg_fail(1)) SWIG_fail;
22495 {
22496 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22497 if (SWIG_arg_fail(2)) SWIG_fail;
22498 if (arg2 == NULL) {
22499 SWIG_null_ref("wxTimeSpan");
22500 }
22501 if (SWIG_arg_fail(2)) SWIG_fail;
22502 }
22503 {
22504 PyThreadState* __tstate = wxPyBeginAllowThreads();
22505 {
22506 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan 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, 1);
22514 return resultobj;
22515 fail:
22516 return NULL;
22517 }
22518
22519
22520 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22521 PyObject *resultobj;
22522 wxDateTime *arg1 = (wxDateTime *) 0 ;
22523 wxDateSpan *arg2 = 0 ;
22524 wxDateTime *result;
22525 PyObject * obj0 = 0 ;
22526 PyObject * obj1 = 0 ;
22527
22528 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22530 if (SWIG_arg_fail(1)) SWIG_fail;
22531 {
22532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22533 if (SWIG_arg_fail(2)) SWIG_fail;
22534 if (arg2 == NULL) {
22535 SWIG_null_ref("wxDateSpan");
22536 }
22537 if (SWIG_arg_fail(2)) SWIG_fail;
22538 }
22539 {
22540 PyThreadState* __tstate = wxPyBeginAllowThreads();
22541 {
22542 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22543 result = (wxDateTime *) &_result_ref;
22544 }
22545
22546 wxPyEndAllowThreads(__tstate);
22547 if (PyErr_Occurred()) SWIG_fail;
22548 }
22549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22550 return resultobj;
22551 fail:
22552 return NULL;
22553 }
22554
22555
22556 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22557 int argc;
22558 PyObject *argv[3];
22559 int ii;
22560
22561 argc = PyObject_Length(args);
22562 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22563 argv[ii] = PyTuple_GetItem(args,ii);
22564 }
22565 if (argc == 2) {
22566 int _v;
22567 {
22568 void *ptr;
22569 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22570 _v = 0;
22571 PyErr_Clear();
22572 } else {
22573 _v = 1;
22574 }
22575 }
22576 if (_v) {
22577 {
22578 void *ptr = 0;
22579 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22580 _v = 0;
22581 PyErr_Clear();
22582 } else {
22583 _v = (ptr != 0);
22584 }
22585 }
22586 if (_v) {
22587 return _wrap_DateTime___isub____SWIG_0(self,args);
22588 }
22589 }
22590 }
22591 if (argc == 2) {
22592 int _v;
22593 {
22594 void *ptr;
22595 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22596 _v = 0;
22597 PyErr_Clear();
22598 } else {
22599 _v = 1;
22600 }
22601 }
22602 if (_v) {
22603 {
22604 void *ptr = 0;
22605 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22606 _v = 0;
22607 PyErr_Clear();
22608 } else {
22609 _v = (ptr != 0);
22610 }
22611 }
22612 if (_v) {
22613 return _wrap_DateTime___isub____SWIG_1(self,args);
22614 }
22615 }
22616 }
22617
22618 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22619 return NULL;
22620 }
22621
22622
22623 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22624 PyObject *resultobj;
22625 wxDateTime *arg1 = (wxDateTime *) 0 ;
22626 wxTimeSpan *arg2 = 0 ;
22627 wxDateTime result;
22628 PyObject * obj0 = 0 ;
22629 PyObject * obj1 = 0 ;
22630
22631 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22633 if (SWIG_arg_fail(1)) SWIG_fail;
22634 {
22635 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22636 if (SWIG_arg_fail(2)) SWIG_fail;
22637 if (arg2 == NULL) {
22638 SWIG_null_ref("wxTimeSpan");
22639 }
22640 if (SWIG_arg_fail(2)) SWIG_fail;
22641 }
22642 {
22643 PyThreadState* __tstate = wxPyBeginAllowThreads();
22644 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22645
22646 wxPyEndAllowThreads(__tstate);
22647 if (PyErr_Occurred()) SWIG_fail;
22648 }
22649 {
22650 wxDateTime * resultptr;
22651 resultptr = new wxDateTime((wxDateTime &)(result));
22652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22653 }
22654 return resultobj;
22655 fail:
22656 return NULL;
22657 }
22658
22659
22660 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22661 PyObject *resultobj;
22662 wxDateTime *arg1 = (wxDateTime *) 0 ;
22663 wxDateSpan *arg2 = 0 ;
22664 wxDateTime result;
22665 PyObject * obj0 = 0 ;
22666 PyObject * obj1 = 0 ;
22667
22668 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22670 if (SWIG_arg_fail(1)) SWIG_fail;
22671 {
22672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22673 if (SWIG_arg_fail(2)) SWIG_fail;
22674 if (arg2 == NULL) {
22675 SWIG_null_ref("wxDateSpan");
22676 }
22677 if (SWIG_arg_fail(2)) SWIG_fail;
22678 }
22679 {
22680 PyThreadState* __tstate = wxPyBeginAllowThreads();
22681 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22682
22683 wxPyEndAllowThreads(__tstate);
22684 if (PyErr_Occurred()) SWIG_fail;
22685 }
22686 {
22687 wxDateTime * resultptr;
22688 resultptr = new wxDateTime((wxDateTime &)(result));
22689 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22690 }
22691 return resultobj;
22692 fail:
22693 return NULL;
22694 }
22695
22696
22697 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22698 int argc;
22699 PyObject *argv[3];
22700 int ii;
22701
22702 argc = PyObject_Length(args);
22703 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22704 argv[ii] = PyTuple_GetItem(args,ii);
22705 }
22706 if (argc == 2) {
22707 int _v;
22708 {
22709 void *ptr;
22710 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22711 _v = 0;
22712 PyErr_Clear();
22713 } else {
22714 _v = 1;
22715 }
22716 }
22717 if (_v) {
22718 {
22719 void *ptr = 0;
22720 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22721 _v = 0;
22722 PyErr_Clear();
22723 } else {
22724 _v = (ptr != 0);
22725 }
22726 }
22727 if (_v) {
22728 return _wrap_DateTime___add____SWIG_0(self,args);
22729 }
22730 }
22731 }
22732 if (argc == 2) {
22733 int _v;
22734 {
22735 void *ptr;
22736 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22737 _v = 0;
22738 PyErr_Clear();
22739 } else {
22740 _v = 1;
22741 }
22742 }
22743 if (_v) {
22744 {
22745 void *ptr = 0;
22746 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22747 _v = 0;
22748 PyErr_Clear();
22749 } else {
22750 _v = (ptr != 0);
22751 }
22752 }
22753 if (_v) {
22754 return _wrap_DateTime___add____SWIG_1(self,args);
22755 }
22756 }
22757 }
22758
22759 Py_INCREF(Py_NotImplemented);
22760 return Py_NotImplemented;
22761 }
22762
22763
22764 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22765 PyObject *resultobj;
22766 wxDateTime *arg1 = (wxDateTime *) 0 ;
22767 wxDateTime *arg2 = 0 ;
22768 wxTimeSpan result;
22769 PyObject * obj0 = 0 ;
22770 PyObject * obj1 = 0 ;
22771
22772 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22774 if (SWIG_arg_fail(1)) SWIG_fail;
22775 {
22776 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22777 if (SWIG_arg_fail(2)) SWIG_fail;
22778 if (arg2 == NULL) {
22779 SWIG_null_ref("wxDateTime");
22780 }
22781 if (SWIG_arg_fail(2)) SWIG_fail;
22782 }
22783 {
22784 PyThreadState* __tstate = wxPyBeginAllowThreads();
22785 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22786
22787 wxPyEndAllowThreads(__tstate);
22788 if (PyErr_Occurred()) SWIG_fail;
22789 }
22790 {
22791 wxTimeSpan * resultptr;
22792 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22793 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22794 }
22795 return resultobj;
22796 fail:
22797 return NULL;
22798 }
22799
22800
22801 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22802 PyObject *resultobj;
22803 wxDateTime *arg1 = (wxDateTime *) 0 ;
22804 wxTimeSpan *arg2 = 0 ;
22805 wxDateTime result;
22806 PyObject * obj0 = 0 ;
22807 PyObject * obj1 = 0 ;
22808
22809 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22811 if (SWIG_arg_fail(1)) SWIG_fail;
22812 {
22813 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22814 if (SWIG_arg_fail(2)) SWIG_fail;
22815 if (arg2 == NULL) {
22816 SWIG_null_ref("wxTimeSpan");
22817 }
22818 if (SWIG_arg_fail(2)) SWIG_fail;
22819 }
22820 {
22821 PyThreadState* __tstate = wxPyBeginAllowThreads();
22822 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22823
22824 wxPyEndAllowThreads(__tstate);
22825 if (PyErr_Occurred()) SWIG_fail;
22826 }
22827 {
22828 wxDateTime * resultptr;
22829 resultptr = new wxDateTime((wxDateTime &)(result));
22830 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22831 }
22832 return resultobj;
22833 fail:
22834 return NULL;
22835 }
22836
22837
22838 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22839 PyObject *resultobj;
22840 wxDateTime *arg1 = (wxDateTime *) 0 ;
22841 wxDateSpan *arg2 = 0 ;
22842 wxDateTime result;
22843 PyObject * obj0 = 0 ;
22844 PyObject * obj1 = 0 ;
22845
22846 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22848 if (SWIG_arg_fail(1)) SWIG_fail;
22849 {
22850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22851 if (SWIG_arg_fail(2)) SWIG_fail;
22852 if (arg2 == NULL) {
22853 SWIG_null_ref("wxDateSpan");
22854 }
22855 if (SWIG_arg_fail(2)) SWIG_fail;
22856 }
22857 {
22858 PyThreadState* __tstate = wxPyBeginAllowThreads();
22859 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22860
22861 wxPyEndAllowThreads(__tstate);
22862 if (PyErr_Occurred()) SWIG_fail;
22863 }
22864 {
22865 wxDateTime * resultptr;
22866 resultptr = new wxDateTime((wxDateTime &)(result));
22867 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22868 }
22869 return resultobj;
22870 fail:
22871 return NULL;
22872 }
22873
22874
22875 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22876 int argc;
22877 PyObject *argv[3];
22878 int ii;
22879
22880 argc = PyObject_Length(args);
22881 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22882 argv[ii] = PyTuple_GetItem(args,ii);
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_wxDateTime, 0) == -1) {
22899 _v = 0;
22900 PyErr_Clear();
22901 } else {
22902 _v = (ptr != 0);
22903 }
22904 }
22905 if (_v) {
22906 return _wrap_DateTime___sub____SWIG_0(self,args);
22907 }
22908 }
22909 }
22910 if (argc == 2) {
22911 int _v;
22912 {
22913 void *ptr;
22914 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22915 _v = 0;
22916 PyErr_Clear();
22917 } else {
22918 _v = 1;
22919 }
22920 }
22921 if (_v) {
22922 {
22923 void *ptr = 0;
22924 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22925 _v = 0;
22926 PyErr_Clear();
22927 } else {
22928 _v = (ptr != 0);
22929 }
22930 }
22931 if (_v) {
22932 return _wrap_DateTime___sub____SWIG_1(self,args);
22933 }
22934 }
22935 }
22936 if (argc == 2) {
22937 int _v;
22938 {
22939 void *ptr;
22940 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22941 _v = 0;
22942 PyErr_Clear();
22943 } else {
22944 _v = 1;
22945 }
22946 }
22947 if (_v) {
22948 {
22949 void *ptr = 0;
22950 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22951 _v = 0;
22952 PyErr_Clear();
22953 } else {
22954 _v = (ptr != 0);
22955 }
22956 }
22957 if (_v) {
22958 return _wrap_DateTime___sub____SWIG_2(self,args);
22959 }
22960 }
22961 }
22962
22963 Py_INCREF(Py_NotImplemented);
22964 return Py_NotImplemented;
22965 }
22966
22967
22968 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
22969 PyObject *resultobj;
22970 wxDateTime *arg1 = (wxDateTime *) 0 ;
22971 wxDateTime *arg2 = (wxDateTime *) 0 ;
22972 bool result;
22973 PyObject * obj0 = 0 ;
22974 PyObject * obj1 = 0 ;
22975 char *kwnames[] = {
22976 (char *) "self",(char *) "other", NULL
22977 };
22978
22979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
22980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22981 if (SWIG_arg_fail(1)) SWIG_fail;
22982 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22983 if (SWIG_arg_fail(2)) SWIG_fail;
22984 {
22985 PyThreadState* __tstate = wxPyBeginAllowThreads();
22986 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
22987
22988 wxPyEndAllowThreads(__tstate);
22989 if (PyErr_Occurred()) SWIG_fail;
22990 }
22991 {
22992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22993 }
22994 return resultobj;
22995 fail:
22996 return NULL;
22997 }
22998
22999
23000 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23001 PyObject *resultobj;
23002 wxDateTime *arg1 = (wxDateTime *) 0 ;
23003 wxDateTime *arg2 = (wxDateTime *) 0 ;
23004 bool result;
23005 PyObject * obj0 = 0 ;
23006 PyObject * obj1 = 0 ;
23007 char *kwnames[] = {
23008 (char *) "self",(char *) "other", NULL
23009 };
23010
23011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23013 if (SWIG_arg_fail(1)) SWIG_fail;
23014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23015 if (SWIG_arg_fail(2)) SWIG_fail;
23016 {
23017 PyThreadState* __tstate = wxPyBeginAllowThreads();
23018 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23019
23020 wxPyEndAllowThreads(__tstate);
23021 if (PyErr_Occurred()) SWIG_fail;
23022 }
23023 {
23024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23025 }
23026 return resultobj;
23027 fail:
23028 return NULL;
23029 }
23030
23031
23032 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23033 PyObject *resultobj;
23034 wxDateTime *arg1 = (wxDateTime *) 0 ;
23035 wxDateTime *arg2 = (wxDateTime *) 0 ;
23036 bool result;
23037 PyObject * obj0 = 0 ;
23038 PyObject * obj1 = 0 ;
23039 char *kwnames[] = {
23040 (char *) "self",(char *) "other", NULL
23041 };
23042
23043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23045 if (SWIG_arg_fail(1)) SWIG_fail;
23046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23047 if (SWIG_arg_fail(2)) SWIG_fail;
23048 {
23049 PyThreadState* __tstate = wxPyBeginAllowThreads();
23050 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23051
23052 wxPyEndAllowThreads(__tstate);
23053 if (PyErr_Occurred()) SWIG_fail;
23054 }
23055 {
23056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23057 }
23058 return resultobj;
23059 fail:
23060 return NULL;
23061 }
23062
23063
23064 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23065 PyObject *resultobj;
23066 wxDateTime *arg1 = (wxDateTime *) 0 ;
23067 wxDateTime *arg2 = (wxDateTime *) 0 ;
23068 bool result;
23069 PyObject * obj0 = 0 ;
23070 PyObject * obj1 = 0 ;
23071 char *kwnames[] = {
23072 (char *) "self",(char *) "other", NULL
23073 };
23074
23075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23077 if (SWIG_arg_fail(1)) SWIG_fail;
23078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23079 if (SWIG_arg_fail(2)) SWIG_fail;
23080 {
23081 PyThreadState* __tstate = wxPyBeginAllowThreads();
23082 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23083
23084 wxPyEndAllowThreads(__tstate);
23085 if (PyErr_Occurred()) SWIG_fail;
23086 }
23087 {
23088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23089 }
23090 return resultobj;
23091 fail:
23092 return NULL;
23093 }
23094
23095
23096 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23097 PyObject *resultobj;
23098 wxDateTime *arg1 = (wxDateTime *) 0 ;
23099 wxDateTime *arg2 = (wxDateTime *) 0 ;
23100 bool result;
23101 PyObject * obj0 = 0 ;
23102 PyObject * obj1 = 0 ;
23103 char *kwnames[] = {
23104 (char *) "self",(char *) "other", NULL
23105 };
23106
23107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23109 if (SWIG_arg_fail(1)) SWIG_fail;
23110 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23111 if (SWIG_arg_fail(2)) SWIG_fail;
23112 {
23113 PyThreadState* __tstate = wxPyBeginAllowThreads();
23114 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23115
23116 wxPyEndAllowThreads(__tstate);
23117 if (PyErr_Occurred()) SWIG_fail;
23118 }
23119 {
23120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23121 }
23122 return resultobj;
23123 fail:
23124 return NULL;
23125 }
23126
23127
23128 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23129 PyObject *resultobj;
23130 wxDateTime *arg1 = (wxDateTime *) 0 ;
23131 wxDateTime *arg2 = (wxDateTime *) 0 ;
23132 bool result;
23133 PyObject * obj0 = 0 ;
23134 PyObject * obj1 = 0 ;
23135 char *kwnames[] = {
23136 (char *) "self",(char *) "other", NULL
23137 };
23138
23139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23143 if (SWIG_arg_fail(2)) SWIG_fail;
23144 {
23145 PyThreadState* __tstate = wxPyBeginAllowThreads();
23146 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23147
23148 wxPyEndAllowThreads(__tstate);
23149 if (PyErr_Occurred()) SWIG_fail;
23150 }
23151 {
23152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23153 }
23154 return resultobj;
23155 fail:
23156 return NULL;
23157 }
23158
23159
23160 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23161 PyObject *resultobj;
23162 wxDateTime *arg1 = (wxDateTime *) 0 ;
23163 wxString *arg2 = 0 ;
23164 int result;
23165 bool temp2 = false ;
23166 PyObject * obj0 = 0 ;
23167 PyObject * obj1 = 0 ;
23168 char *kwnames[] = {
23169 (char *) "self",(char *) "date", NULL
23170 };
23171
23172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23174 if (SWIG_arg_fail(1)) SWIG_fail;
23175 {
23176 arg2 = wxString_in_helper(obj1);
23177 if (arg2 == NULL) SWIG_fail;
23178 temp2 = true;
23179 }
23180 {
23181 PyThreadState* __tstate = wxPyBeginAllowThreads();
23182 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23183
23184 wxPyEndAllowThreads(__tstate);
23185 if (PyErr_Occurred()) SWIG_fail;
23186 }
23187 {
23188 resultobj = SWIG_From_int((int)(result));
23189 }
23190 {
23191 if (temp2)
23192 delete arg2;
23193 }
23194 return resultobj;
23195 fail:
23196 {
23197 if (temp2)
23198 delete arg2;
23199 }
23200 return NULL;
23201 }
23202
23203
23204 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23205 PyObject *resultobj;
23206 wxDateTime *arg1 = (wxDateTime *) 0 ;
23207 wxString *arg2 = 0 ;
23208 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23209 wxString *arg3 = (wxString *) &arg3_defvalue ;
23210 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23211 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23212 int result;
23213 bool temp2 = false ;
23214 bool temp3 = false ;
23215 PyObject * obj0 = 0 ;
23216 PyObject * obj1 = 0 ;
23217 PyObject * obj2 = 0 ;
23218 PyObject * obj3 = 0 ;
23219 char *kwnames[] = {
23220 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23221 };
23222
23223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23225 if (SWIG_arg_fail(1)) SWIG_fail;
23226 {
23227 arg2 = wxString_in_helper(obj1);
23228 if (arg2 == NULL) SWIG_fail;
23229 temp2 = true;
23230 }
23231 if (obj2) {
23232 {
23233 arg3 = wxString_in_helper(obj2);
23234 if (arg3 == NULL) SWIG_fail;
23235 temp3 = true;
23236 }
23237 }
23238 if (obj3) {
23239 {
23240 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23241 if (SWIG_arg_fail(4)) SWIG_fail;
23242 if (arg4 == NULL) {
23243 SWIG_null_ref("wxDateTime");
23244 }
23245 if (SWIG_arg_fail(4)) SWIG_fail;
23246 }
23247 }
23248 {
23249 PyThreadState* __tstate = wxPyBeginAllowThreads();
23250 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23251
23252 wxPyEndAllowThreads(__tstate);
23253 if (PyErr_Occurred()) SWIG_fail;
23254 }
23255 {
23256 resultobj = SWIG_From_int((int)(result));
23257 }
23258 {
23259 if (temp2)
23260 delete arg2;
23261 }
23262 {
23263 if (temp3)
23264 delete arg3;
23265 }
23266 return resultobj;
23267 fail:
23268 {
23269 if (temp2)
23270 delete arg2;
23271 }
23272 {
23273 if (temp3)
23274 delete arg3;
23275 }
23276 return NULL;
23277 }
23278
23279
23280 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23281 PyObject *resultobj;
23282 wxDateTime *arg1 = (wxDateTime *) 0 ;
23283 wxString *arg2 = 0 ;
23284 int result;
23285 bool temp2 = false ;
23286 PyObject * obj0 = 0 ;
23287 PyObject * obj1 = 0 ;
23288 char *kwnames[] = {
23289 (char *) "self",(char *) "datetime", NULL
23290 };
23291
23292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23294 if (SWIG_arg_fail(1)) SWIG_fail;
23295 {
23296 arg2 = wxString_in_helper(obj1);
23297 if (arg2 == NULL) SWIG_fail;
23298 temp2 = true;
23299 }
23300 {
23301 PyThreadState* __tstate = wxPyBeginAllowThreads();
23302 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23303
23304 wxPyEndAllowThreads(__tstate);
23305 if (PyErr_Occurred()) SWIG_fail;
23306 }
23307 {
23308 resultobj = SWIG_From_int((int)(result));
23309 }
23310 {
23311 if (temp2)
23312 delete arg2;
23313 }
23314 return resultobj;
23315 fail:
23316 {
23317 if (temp2)
23318 delete arg2;
23319 }
23320 return NULL;
23321 }
23322
23323
23324 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23325 PyObject *resultobj;
23326 wxDateTime *arg1 = (wxDateTime *) 0 ;
23327 wxString *arg2 = 0 ;
23328 int result;
23329 bool temp2 = false ;
23330 PyObject * obj0 = 0 ;
23331 PyObject * obj1 = 0 ;
23332 char *kwnames[] = {
23333 (char *) "self",(char *) "date", NULL
23334 };
23335
23336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",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 {
23340 arg2 = wxString_in_helper(obj1);
23341 if (arg2 == NULL) SWIG_fail;
23342 temp2 = true;
23343 }
23344 {
23345 PyThreadState* __tstate = wxPyBeginAllowThreads();
23346 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23347
23348 wxPyEndAllowThreads(__tstate);
23349 if (PyErr_Occurred()) SWIG_fail;
23350 }
23351 {
23352 resultobj = SWIG_From_int((int)(result));
23353 }
23354 {
23355 if (temp2)
23356 delete arg2;
23357 }
23358 return resultobj;
23359 fail:
23360 {
23361 if (temp2)
23362 delete arg2;
23363 }
23364 return NULL;
23365 }
23366
23367
23368 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23369 PyObject *resultobj;
23370 wxDateTime *arg1 = (wxDateTime *) 0 ;
23371 wxString *arg2 = 0 ;
23372 int result;
23373 bool temp2 = false ;
23374 PyObject * obj0 = 0 ;
23375 PyObject * obj1 = 0 ;
23376 char *kwnames[] = {
23377 (char *) "self",(char *) "time", NULL
23378 };
23379
23380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23382 if (SWIG_arg_fail(1)) SWIG_fail;
23383 {
23384 arg2 = wxString_in_helper(obj1);
23385 if (arg2 == NULL) SWIG_fail;
23386 temp2 = true;
23387 }
23388 {
23389 PyThreadState* __tstate = wxPyBeginAllowThreads();
23390 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23391
23392 wxPyEndAllowThreads(__tstate);
23393 if (PyErr_Occurred()) SWIG_fail;
23394 }
23395 {
23396 resultobj = SWIG_From_int((int)(result));
23397 }
23398 {
23399 if (temp2)
23400 delete arg2;
23401 }
23402 return resultobj;
23403 fail:
23404 {
23405 if (temp2)
23406 delete arg2;
23407 }
23408 return NULL;
23409 }
23410
23411
23412 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23413 PyObject *resultobj;
23414 wxDateTime *arg1 = (wxDateTime *) 0 ;
23415 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23416 wxString *arg2 = (wxString *) &arg2_defvalue ;
23417 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23418 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23419 wxString result;
23420 bool temp2 = false ;
23421 bool temp3 = false ;
23422 PyObject * obj0 = 0 ;
23423 PyObject * obj1 = 0 ;
23424 PyObject * obj2 = 0 ;
23425 char *kwnames[] = {
23426 (char *) "self",(char *) "format",(char *) "tz", NULL
23427 };
23428
23429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23431 if (SWIG_arg_fail(1)) SWIG_fail;
23432 if (obj1) {
23433 {
23434 arg2 = wxString_in_helper(obj1);
23435 if (arg2 == NULL) SWIG_fail;
23436 temp2 = true;
23437 }
23438 }
23439 if (obj2) {
23440 {
23441 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23442 temp3 = true;
23443 }
23444 }
23445 {
23446 PyThreadState* __tstate = wxPyBeginAllowThreads();
23447 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23448
23449 wxPyEndAllowThreads(__tstate);
23450 if (PyErr_Occurred()) SWIG_fail;
23451 }
23452 {
23453 #if wxUSE_UNICODE
23454 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23455 #else
23456 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23457 #endif
23458 }
23459 {
23460 if (temp2)
23461 delete arg2;
23462 }
23463 {
23464 if (temp3) delete arg3;
23465 }
23466 return resultobj;
23467 fail:
23468 {
23469 if (temp2)
23470 delete arg2;
23471 }
23472 {
23473 if (temp3) delete arg3;
23474 }
23475 return NULL;
23476 }
23477
23478
23479 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23480 PyObject *resultobj;
23481 wxDateTime *arg1 = (wxDateTime *) 0 ;
23482 wxString result;
23483 PyObject * obj0 = 0 ;
23484 char *kwnames[] = {
23485 (char *) "self", NULL
23486 };
23487
23488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23490 if (SWIG_arg_fail(1)) SWIG_fail;
23491 {
23492 PyThreadState* __tstate = wxPyBeginAllowThreads();
23493 result = ((wxDateTime const *)arg1)->FormatDate();
23494
23495 wxPyEndAllowThreads(__tstate);
23496 if (PyErr_Occurred()) SWIG_fail;
23497 }
23498 {
23499 #if wxUSE_UNICODE
23500 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23501 #else
23502 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23503 #endif
23504 }
23505 return resultobj;
23506 fail:
23507 return NULL;
23508 }
23509
23510
23511 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23512 PyObject *resultobj;
23513 wxDateTime *arg1 = (wxDateTime *) 0 ;
23514 wxString result;
23515 PyObject * obj0 = 0 ;
23516 char *kwnames[] = {
23517 (char *) "self", NULL
23518 };
23519
23520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23522 if (SWIG_arg_fail(1)) SWIG_fail;
23523 {
23524 PyThreadState* __tstate = wxPyBeginAllowThreads();
23525 result = ((wxDateTime const *)arg1)->FormatTime();
23526
23527 wxPyEndAllowThreads(__tstate);
23528 if (PyErr_Occurred()) SWIG_fail;
23529 }
23530 {
23531 #if wxUSE_UNICODE
23532 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23533 #else
23534 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23535 #endif
23536 }
23537 return resultobj;
23538 fail:
23539 return NULL;
23540 }
23541
23542
23543 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23544 PyObject *resultobj;
23545 wxDateTime *arg1 = (wxDateTime *) 0 ;
23546 wxString result;
23547 PyObject * obj0 = 0 ;
23548 char *kwnames[] = {
23549 (char *) "self", NULL
23550 };
23551
23552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23554 if (SWIG_arg_fail(1)) SWIG_fail;
23555 {
23556 PyThreadState* __tstate = wxPyBeginAllowThreads();
23557 result = ((wxDateTime const *)arg1)->FormatISODate();
23558
23559 wxPyEndAllowThreads(__tstate);
23560 if (PyErr_Occurred()) SWIG_fail;
23561 }
23562 {
23563 #if wxUSE_UNICODE
23564 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23565 #else
23566 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23567 #endif
23568 }
23569 return resultobj;
23570 fail:
23571 return NULL;
23572 }
23573
23574
23575 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23576 PyObject *resultobj;
23577 wxDateTime *arg1 = (wxDateTime *) 0 ;
23578 wxString result;
23579 PyObject * obj0 = 0 ;
23580 char *kwnames[] = {
23581 (char *) "self", NULL
23582 };
23583
23584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23586 if (SWIG_arg_fail(1)) SWIG_fail;
23587 {
23588 PyThreadState* __tstate = wxPyBeginAllowThreads();
23589 result = ((wxDateTime const *)arg1)->FormatISOTime();
23590
23591 wxPyEndAllowThreads(__tstate);
23592 if (PyErr_Occurred()) SWIG_fail;
23593 }
23594 {
23595 #if wxUSE_UNICODE
23596 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23597 #else
23598 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23599 #endif
23600 }
23601 return resultobj;
23602 fail:
23603 return NULL;
23604 }
23605
23606
23607 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23608 PyObject *obj;
23609 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23610 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23611 Py_INCREF(obj);
23612 return Py_BuildValue((char *)"");
23613 }
23614 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23615 PyObject *resultobj;
23616 long arg1 ;
23617 wxTimeSpan result;
23618 PyObject * obj0 = 0 ;
23619 char *kwnames[] = {
23620 (char *) "sec", NULL
23621 };
23622
23623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23624 {
23625 arg1 = (long)(SWIG_As_long(obj0));
23626 if (SWIG_arg_fail(1)) SWIG_fail;
23627 }
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 result = wxTimeSpan::Seconds(arg1);
23631
23632 wxPyEndAllowThreads(__tstate);
23633 if (PyErr_Occurred()) SWIG_fail;
23634 }
23635 {
23636 wxTimeSpan * resultptr;
23637 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23638 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23639 }
23640 return resultobj;
23641 fail:
23642 return NULL;
23643 }
23644
23645
23646 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23647 PyObject *resultobj;
23648 wxTimeSpan result;
23649 char *kwnames[] = {
23650 NULL
23651 };
23652
23653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23654 {
23655 PyThreadState* __tstate = wxPyBeginAllowThreads();
23656 result = wxTimeSpan::Second();
23657
23658 wxPyEndAllowThreads(__tstate);
23659 if (PyErr_Occurred()) SWIG_fail;
23660 }
23661 {
23662 wxTimeSpan * resultptr;
23663 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23665 }
23666 return resultobj;
23667 fail:
23668 return NULL;
23669 }
23670
23671
23672 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23673 PyObject *resultobj;
23674 long arg1 ;
23675 wxTimeSpan result;
23676 PyObject * obj0 = 0 ;
23677 char *kwnames[] = {
23678 (char *) "min", NULL
23679 };
23680
23681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23682 {
23683 arg1 = (long)(SWIG_As_long(obj0));
23684 if (SWIG_arg_fail(1)) SWIG_fail;
23685 }
23686 {
23687 PyThreadState* __tstate = wxPyBeginAllowThreads();
23688 result = wxTimeSpan::Minutes(arg1);
23689
23690 wxPyEndAllowThreads(__tstate);
23691 if (PyErr_Occurred()) SWIG_fail;
23692 }
23693 {
23694 wxTimeSpan * resultptr;
23695 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23696 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23697 }
23698 return resultobj;
23699 fail:
23700 return NULL;
23701 }
23702
23703
23704 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23705 PyObject *resultobj;
23706 wxTimeSpan result;
23707 char *kwnames[] = {
23708 NULL
23709 };
23710
23711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23712 {
23713 PyThreadState* __tstate = wxPyBeginAllowThreads();
23714 result = wxTimeSpan::Minute();
23715
23716 wxPyEndAllowThreads(__tstate);
23717 if (PyErr_Occurred()) SWIG_fail;
23718 }
23719 {
23720 wxTimeSpan * resultptr;
23721 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23722 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23723 }
23724 return resultobj;
23725 fail:
23726 return NULL;
23727 }
23728
23729
23730 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23731 PyObject *resultobj;
23732 long arg1 ;
23733 wxTimeSpan result;
23734 PyObject * obj0 = 0 ;
23735 char *kwnames[] = {
23736 (char *) "hours", NULL
23737 };
23738
23739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23740 {
23741 arg1 = (long)(SWIG_As_long(obj0));
23742 if (SWIG_arg_fail(1)) SWIG_fail;
23743 }
23744 {
23745 PyThreadState* __tstate = wxPyBeginAllowThreads();
23746 result = wxTimeSpan::Hours(arg1);
23747
23748 wxPyEndAllowThreads(__tstate);
23749 if (PyErr_Occurred()) SWIG_fail;
23750 }
23751 {
23752 wxTimeSpan * resultptr;
23753 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23754 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23755 }
23756 return resultobj;
23757 fail:
23758 return NULL;
23759 }
23760
23761
23762 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23763 PyObject *resultobj;
23764 wxTimeSpan result;
23765 char *kwnames[] = {
23766 NULL
23767 };
23768
23769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23770 {
23771 PyThreadState* __tstate = wxPyBeginAllowThreads();
23772 result = wxTimeSpan::Hour();
23773
23774 wxPyEndAllowThreads(__tstate);
23775 if (PyErr_Occurred()) SWIG_fail;
23776 }
23777 {
23778 wxTimeSpan * resultptr;
23779 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23780 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23781 }
23782 return resultobj;
23783 fail:
23784 return NULL;
23785 }
23786
23787
23788 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23789 PyObject *resultobj;
23790 long arg1 ;
23791 wxTimeSpan result;
23792 PyObject * obj0 = 0 ;
23793 char *kwnames[] = {
23794 (char *) "days", NULL
23795 };
23796
23797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23798 {
23799 arg1 = (long)(SWIG_As_long(obj0));
23800 if (SWIG_arg_fail(1)) SWIG_fail;
23801 }
23802 {
23803 PyThreadState* __tstate = wxPyBeginAllowThreads();
23804 result = wxTimeSpan::Days(arg1);
23805
23806 wxPyEndAllowThreads(__tstate);
23807 if (PyErr_Occurred()) SWIG_fail;
23808 }
23809 {
23810 wxTimeSpan * resultptr;
23811 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23812 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23813 }
23814 return resultobj;
23815 fail:
23816 return NULL;
23817 }
23818
23819
23820 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23821 PyObject *resultobj;
23822 wxTimeSpan result;
23823 char *kwnames[] = {
23824 NULL
23825 };
23826
23827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23828 {
23829 PyThreadState* __tstate = wxPyBeginAllowThreads();
23830 result = wxTimeSpan::Day();
23831
23832 wxPyEndAllowThreads(__tstate);
23833 if (PyErr_Occurred()) SWIG_fail;
23834 }
23835 {
23836 wxTimeSpan * resultptr;
23837 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23838 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23839 }
23840 return resultobj;
23841 fail:
23842 return NULL;
23843 }
23844
23845
23846 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23847 PyObject *resultobj;
23848 long arg1 ;
23849 wxTimeSpan result;
23850 PyObject * obj0 = 0 ;
23851 char *kwnames[] = {
23852 (char *) "days", NULL
23853 };
23854
23855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23856 {
23857 arg1 = (long)(SWIG_As_long(obj0));
23858 if (SWIG_arg_fail(1)) SWIG_fail;
23859 }
23860 {
23861 PyThreadState* __tstate = wxPyBeginAllowThreads();
23862 result = wxTimeSpan::Weeks(arg1);
23863
23864 wxPyEndAllowThreads(__tstate);
23865 if (PyErr_Occurred()) SWIG_fail;
23866 }
23867 {
23868 wxTimeSpan * resultptr;
23869 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23870 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23871 }
23872 return resultobj;
23873 fail:
23874 return NULL;
23875 }
23876
23877
23878 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23879 PyObject *resultobj;
23880 wxTimeSpan result;
23881 char *kwnames[] = {
23882 NULL
23883 };
23884
23885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23886 {
23887 PyThreadState* __tstate = wxPyBeginAllowThreads();
23888 result = wxTimeSpan::Week();
23889
23890 wxPyEndAllowThreads(__tstate);
23891 if (PyErr_Occurred()) SWIG_fail;
23892 }
23893 {
23894 wxTimeSpan * resultptr;
23895 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23896 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23897 }
23898 return resultobj;
23899 fail:
23900 return NULL;
23901 }
23902
23903
23904 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23905 PyObject *resultobj;
23906 long arg1 = (long) 0 ;
23907 long arg2 = (long) 0 ;
23908 long arg3 = (long) 0 ;
23909 long arg4 = (long) 0 ;
23910 wxTimeSpan *result;
23911 PyObject * obj0 = 0 ;
23912 PyObject * obj1 = 0 ;
23913 PyObject * obj2 = 0 ;
23914 PyObject * obj3 = 0 ;
23915 char *kwnames[] = {
23916 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
23917 };
23918
23919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23920 if (obj0) {
23921 {
23922 arg1 = (long)(SWIG_As_long(obj0));
23923 if (SWIG_arg_fail(1)) SWIG_fail;
23924 }
23925 }
23926 if (obj1) {
23927 {
23928 arg2 = (long)(SWIG_As_long(obj1));
23929 if (SWIG_arg_fail(2)) SWIG_fail;
23930 }
23931 }
23932 if (obj2) {
23933 {
23934 arg3 = (long)(SWIG_As_long(obj2));
23935 if (SWIG_arg_fail(3)) SWIG_fail;
23936 }
23937 }
23938 if (obj3) {
23939 {
23940 arg4 = (long)(SWIG_As_long(obj3));
23941 if (SWIG_arg_fail(4)) SWIG_fail;
23942 }
23943 }
23944 {
23945 PyThreadState* __tstate = wxPyBeginAllowThreads();
23946 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
23947
23948 wxPyEndAllowThreads(__tstate);
23949 if (PyErr_Occurred()) SWIG_fail;
23950 }
23951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23952 return resultobj;
23953 fail:
23954 return NULL;
23955 }
23956
23957
23958 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23959 PyObject *resultobj;
23960 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23961 PyObject * obj0 = 0 ;
23962 char *kwnames[] = {
23963 (char *) "self", NULL
23964 };
23965
23966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
23967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23968 if (SWIG_arg_fail(1)) SWIG_fail;
23969 {
23970 PyThreadState* __tstate = wxPyBeginAllowThreads();
23971 delete arg1;
23972
23973 wxPyEndAllowThreads(__tstate);
23974 if (PyErr_Occurred()) SWIG_fail;
23975 }
23976 Py_INCREF(Py_None); resultobj = Py_None;
23977 return resultobj;
23978 fail:
23979 return NULL;
23980 }
23981
23982
23983 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
23984 PyObject *resultobj;
23985 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23986 wxTimeSpan *arg2 = 0 ;
23987 wxTimeSpan *result;
23988 PyObject * obj0 = 0 ;
23989 PyObject * obj1 = 0 ;
23990 char *kwnames[] = {
23991 (char *) "self",(char *) "diff", NULL
23992 };
23993
23994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
23995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23996 if (SWIG_arg_fail(1)) SWIG_fail;
23997 {
23998 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23999 if (SWIG_arg_fail(2)) SWIG_fail;
24000 if (arg2 == NULL) {
24001 SWIG_null_ref("wxTimeSpan");
24002 }
24003 if (SWIG_arg_fail(2)) SWIG_fail;
24004 }
24005 {
24006 PyThreadState* __tstate = wxPyBeginAllowThreads();
24007 {
24008 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24009 result = (wxTimeSpan *) &_result_ref;
24010 }
24011
24012 wxPyEndAllowThreads(__tstate);
24013 if (PyErr_Occurred()) SWIG_fail;
24014 }
24015 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24016 return resultobj;
24017 fail:
24018 return NULL;
24019 }
24020
24021
24022 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24023 PyObject *resultobj;
24024 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24025 wxTimeSpan *arg2 = 0 ;
24026 wxTimeSpan *result;
24027 PyObject * obj0 = 0 ;
24028 PyObject * obj1 = 0 ;
24029 char *kwnames[] = {
24030 (char *) "self",(char *) "diff", NULL
24031 };
24032
24033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24035 if (SWIG_arg_fail(1)) SWIG_fail;
24036 {
24037 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24038 if (SWIG_arg_fail(2)) SWIG_fail;
24039 if (arg2 == NULL) {
24040 SWIG_null_ref("wxTimeSpan");
24041 }
24042 if (SWIG_arg_fail(2)) SWIG_fail;
24043 }
24044 {
24045 PyThreadState* __tstate = wxPyBeginAllowThreads();
24046 {
24047 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24048 result = (wxTimeSpan *) &_result_ref;
24049 }
24050
24051 wxPyEndAllowThreads(__tstate);
24052 if (PyErr_Occurred()) SWIG_fail;
24053 }
24054 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24055 return resultobj;
24056 fail:
24057 return NULL;
24058 }
24059
24060
24061 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24062 PyObject *resultobj;
24063 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24064 int arg2 ;
24065 wxTimeSpan *result;
24066 PyObject * obj0 = 0 ;
24067 PyObject * obj1 = 0 ;
24068 char *kwnames[] = {
24069 (char *) "self",(char *) "n", NULL
24070 };
24071
24072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24074 if (SWIG_arg_fail(1)) SWIG_fail;
24075 {
24076 arg2 = (int)(SWIG_As_int(obj1));
24077 if (SWIG_arg_fail(2)) SWIG_fail;
24078 }
24079 {
24080 PyThreadState* __tstate = wxPyBeginAllowThreads();
24081 {
24082 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24083 result = (wxTimeSpan *) &_result_ref;
24084 }
24085
24086 wxPyEndAllowThreads(__tstate);
24087 if (PyErr_Occurred()) SWIG_fail;
24088 }
24089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24090 return resultobj;
24091 fail:
24092 return NULL;
24093 }
24094
24095
24096 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24097 PyObject *resultobj;
24098 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24099 wxTimeSpan *result;
24100 PyObject * obj0 = 0 ;
24101 char *kwnames[] = {
24102 (char *) "self", NULL
24103 };
24104
24105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24107 if (SWIG_arg_fail(1)) SWIG_fail;
24108 {
24109 PyThreadState* __tstate = wxPyBeginAllowThreads();
24110 {
24111 wxTimeSpan &_result_ref = (arg1)->Neg();
24112 result = (wxTimeSpan *) &_result_ref;
24113 }
24114
24115 wxPyEndAllowThreads(__tstate);
24116 if (PyErr_Occurred()) SWIG_fail;
24117 }
24118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24119 return resultobj;
24120 fail:
24121 return NULL;
24122 }
24123
24124
24125 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24126 PyObject *resultobj;
24127 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24128 wxTimeSpan result;
24129 PyObject * obj0 = 0 ;
24130 char *kwnames[] = {
24131 (char *) "self", NULL
24132 };
24133
24134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24136 if (SWIG_arg_fail(1)) SWIG_fail;
24137 {
24138 PyThreadState* __tstate = wxPyBeginAllowThreads();
24139 result = ((wxTimeSpan const *)arg1)->Abs();
24140
24141 wxPyEndAllowThreads(__tstate);
24142 if (PyErr_Occurred()) SWIG_fail;
24143 }
24144 {
24145 wxTimeSpan * resultptr;
24146 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24147 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24148 }
24149 return resultobj;
24150 fail:
24151 return NULL;
24152 }
24153
24154
24155 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24156 PyObject *resultobj;
24157 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24158 wxTimeSpan *arg2 = 0 ;
24159 wxTimeSpan *result;
24160 PyObject * obj0 = 0 ;
24161 PyObject * obj1 = 0 ;
24162 char *kwnames[] = {
24163 (char *) "self",(char *) "diff", NULL
24164 };
24165
24166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24168 if (SWIG_arg_fail(1)) SWIG_fail;
24169 {
24170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24171 if (SWIG_arg_fail(2)) SWIG_fail;
24172 if (arg2 == NULL) {
24173 SWIG_null_ref("wxTimeSpan");
24174 }
24175 if (SWIG_arg_fail(2)) SWIG_fail;
24176 }
24177 {
24178 PyThreadState* __tstate = wxPyBeginAllowThreads();
24179 {
24180 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24181 result = (wxTimeSpan *) &_result_ref;
24182 }
24183
24184 wxPyEndAllowThreads(__tstate);
24185 if (PyErr_Occurred()) SWIG_fail;
24186 }
24187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24188 return resultobj;
24189 fail:
24190 return NULL;
24191 }
24192
24193
24194 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24195 PyObject *resultobj;
24196 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24197 wxTimeSpan *arg2 = 0 ;
24198 wxTimeSpan *result;
24199 PyObject * obj0 = 0 ;
24200 PyObject * obj1 = 0 ;
24201 char *kwnames[] = {
24202 (char *) "self",(char *) "diff", NULL
24203 };
24204
24205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24207 if (SWIG_arg_fail(1)) SWIG_fail;
24208 {
24209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24210 if (SWIG_arg_fail(2)) SWIG_fail;
24211 if (arg2 == NULL) {
24212 SWIG_null_ref("wxTimeSpan");
24213 }
24214 if (SWIG_arg_fail(2)) SWIG_fail;
24215 }
24216 {
24217 PyThreadState* __tstate = wxPyBeginAllowThreads();
24218 {
24219 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24220 result = (wxTimeSpan *) &_result_ref;
24221 }
24222
24223 wxPyEndAllowThreads(__tstate);
24224 if (PyErr_Occurred()) SWIG_fail;
24225 }
24226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24227 return resultobj;
24228 fail:
24229 return NULL;
24230 }
24231
24232
24233 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24234 PyObject *resultobj;
24235 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24236 int arg2 ;
24237 wxTimeSpan *result;
24238 PyObject * obj0 = 0 ;
24239 PyObject * obj1 = 0 ;
24240 char *kwnames[] = {
24241 (char *) "self",(char *) "n", NULL
24242 };
24243
24244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24246 if (SWIG_arg_fail(1)) SWIG_fail;
24247 {
24248 arg2 = (int)(SWIG_As_int(obj1));
24249 if (SWIG_arg_fail(2)) SWIG_fail;
24250 }
24251 {
24252 PyThreadState* __tstate = wxPyBeginAllowThreads();
24253 {
24254 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24255 result = (wxTimeSpan *) &_result_ref;
24256 }
24257
24258 wxPyEndAllowThreads(__tstate);
24259 if (PyErr_Occurred()) SWIG_fail;
24260 }
24261 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24262 return resultobj;
24263 fail:
24264 return NULL;
24265 }
24266
24267
24268 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24269 PyObject *resultobj;
24270 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24271 wxTimeSpan *result;
24272 PyObject * obj0 = 0 ;
24273 char *kwnames[] = {
24274 (char *) "self", NULL
24275 };
24276
24277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24279 if (SWIG_arg_fail(1)) SWIG_fail;
24280 {
24281 PyThreadState* __tstate = wxPyBeginAllowThreads();
24282 {
24283 wxTimeSpan &_result_ref = (arg1)->operator -();
24284 result = (wxTimeSpan *) &_result_ref;
24285 }
24286
24287 wxPyEndAllowThreads(__tstate);
24288 if (PyErr_Occurred()) SWIG_fail;
24289 }
24290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24291 return resultobj;
24292 fail:
24293 return NULL;
24294 }
24295
24296
24297 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24298 PyObject *resultobj;
24299 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24300 wxTimeSpan *arg2 = 0 ;
24301 wxTimeSpan result;
24302 PyObject * obj0 = 0 ;
24303 PyObject * obj1 = 0 ;
24304 char *kwnames[] = {
24305 (char *) "self",(char *) "other", NULL
24306 };
24307
24308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24310 if (SWIG_arg_fail(1)) SWIG_fail;
24311 {
24312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24313 if (SWIG_arg_fail(2)) SWIG_fail;
24314 if (arg2 == NULL) {
24315 SWIG_null_ref("wxTimeSpan");
24316 }
24317 if (SWIG_arg_fail(2)) SWIG_fail;
24318 }
24319 {
24320 PyThreadState* __tstate = wxPyBeginAllowThreads();
24321 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24322
24323 wxPyEndAllowThreads(__tstate);
24324 if (PyErr_Occurred()) SWIG_fail;
24325 }
24326 {
24327 wxTimeSpan * resultptr;
24328 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24329 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24330 }
24331 return resultobj;
24332 fail:
24333 return NULL;
24334 }
24335
24336
24337 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24338 PyObject *resultobj;
24339 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24340 wxTimeSpan *arg2 = 0 ;
24341 wxTimeSpan result;
24342 PyObject * obj0 = 0 ;
24343 PyObject * obj1 = 0 ;
24344 char *kwnames[] = {
24345 (char *) "self",(char *) "other", NULL
24346 };
24347
24348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24350 if (SWIG_arg_fail(1)) SWIG_fail;
24351 {
24352 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24353 if (SWIG_arg_fail(2)) SWIG_fail;
24354 if (arg2 == NULL) {
24355 SWIG_null_ref("wxTimeSpan");
24356 }
24357 if (SWIG_arg_fail(2)) SWIG_fail;
24358 }
24359 {
24360 PyThreadState* __tstate = wxPyBeginAllowThreads();
24361 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24362
24363 wxPyEndAllowThreads(__tstate);
24364 if (PyErr_Occurred()) SWIG_fail;
24365 }
24366 {
24367 wxTimeSpan * resultptr;
24368 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24369 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24370 }
24371 return resultobj;
24372 fail:
24373 return NULL;
24374 }
24375
24376
24377 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24378 PyObject *resultobj;
24379 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24380 int arg2 ;
24381 wxTimeSpan result;
24382 PyObject * obj0 = 0 ;
24383 PyObject * obj1 = 0 ;
24384 char *kwnames[] = {
24385 (char *) "self",(char *) "n", NULL
24386 };
24387
24388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24390 if (SWIG_arg_fail(1)) SWIG_fail;
24391 {
24392 arg2 = (int)(SWIG_As_int(obj1));
24393 if (SWIG_arg_fail(2)) SWIG_fail;
24394 }
24395 {
24396 PyThreadState* __tstate = wxPyBeginAllowThreads();
24397 result = wxTimeSpan___mul__(arg1,arg2);
24398
24399 wxPyEndAllowThreads(__tstate);
24400 if (PyErr_Occurred()) SWIG_fail;
24401 }
24402 {
24403 wxTimeSpan * resultptr;
24404 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24405 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24406 }
24407 return resultobj;
24408 fail:
24409 return NULL;
24410 }
24411
24412
24413 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24414 PyObject *resultobj;
24415 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24416 int arg2 ;
24417 wxTimeSpan result;
24418 PyObject * obj0 = 0 ;
24419 PyObject * obj1 = 0 ;
24420 char *kwnames[] = {
24421 (char *) "self",(char *) "n", NULL
24422 };
24423
24424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24426 if (SWIG_arg_fail(1)) SWIG_fail;
24427 {
24428 arg2 = (int)(SWIG_As_int(obj1));
24429 if (SWIG_arg_fail(2)) SWIG_fail;
24430 }
24431 {
24432 PyThreadState* __tstate = wxPyBeginAllowThreads();
24433 result = wxTimeSpan___rmul__(arg1,arg2);
24434
24435 wxPyEndAllowThreads(__tstate);
24436 if (PyErr_Occurred()) SWIG_fail;
24437 }
24438 {
24439 wxTimeSpan * resultptr;
24440 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24441 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24442 }
24443 return resultobj;
24444 fail:
24445 return NULL;
24446 }
24447
24448
24449 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24450 PyObject *resultobj;
24451 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24452 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24453 bool result;
24454 PyObject * obj0 = 0 ;
24455 PyObject * obj1 = 0 ;
24456 char *kwnames[] = {
24457 (char *) "self",(char *) "other", NULL
24458 };
24459
24460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24462 if (SWIG_arg_fail(1)) SWIG_fail;
24463 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24464 if (SWIG_arg_fail(2)) SWIG_fail;
24465 {
24466 PyThreadState* __tstate = wxPyBeginAllowThreads();
24467 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24468
24469 wxPyEndAllowThreads(__tstate);
24470 if (PyErr_Occurred()) SWIG_fail;
24471 }
24472 {
24473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24474 }
24475 return resultobj;
24476 fail:
24477 return NULL;
24478 }
24479
24480
24481 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24482 PyObject *resultobj;
24483 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24484 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24485 bool result;
24486 PyObject * obj0 = 0 ;
24487 PyObject * obj1 = 0 ;
24488 char *kwnames[] = {
24489 (char *) "self",(char *) "other", NULL
24490 };
24491
24492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24494 if (SWIG_arg_fail(1)) SWIG_fail;
24495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24496 if (SWIG_arg_fail(2)) SWIG_fail;
24497 {
24498 PyThreadState* __tstate = wxPyBeginAllowThreads();
24499 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24500
24501 wxPyEndAllowThreads(__tstate);
24502 if (PyErr_Occurred()) SWIG_fail;
24503 }
24504 {
24505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24506 }
24507 return resultobj;
24508 fail:
24509 return NULL;
24510 }
24511
24512
24513 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24514 PyObject *resultobj;
24515 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24516 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24517 bool result;
24518 PyObject * obj0 = 0 ;
24519 PyObject * obj1 = 0 ;
24520 char *kwnames[] = {
24521 (char *) "self",(char *) "other", NULL
24522 };
24523
24524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24526 if (SWIG_arg_fail(1)) SWIG_fail;
24527 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24528 if (SWIG_arg_fail(2)) SWIG_fail;
24529 {
24530 PyThreadState* __tstate = wxPyBeginAllowThreads();
24531 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24532
24533 wxPyEndAllowThreads(__tstate);
24534 if (PyErr_Occurred()) SWIG_fail;
24535 }
24536 {
24537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24538 }
24539 return resultobj;
24540 fail:
24541 return NULL;
24542 }
24543
24544
24545 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24546 PyObject *resultobj;
24547 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24548 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24549 bool result;
24550 PyObject * obj0 = 0 ;
24551 PyObject * obj1 = 0 ;
24552 char *kwnames[] = {
24553 (char *) "self",(char *) "other", NULL
24554 };
24555
24556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24558 if (SWIG_arg_fail(1)) SWIG_fail;
24559 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24560 if (SWIG_arg_fail(2)) SWIG_fail;
24561 {
24562 PyThreadState* __tstate = wxPyBeginAllowThreads();
24563 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24564
24565 wxPyEndAllowThreads(__tstate);
24566 if (PyErr_Occurred()) SWIG_fail;
24567 }
24568 {
24569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24570 }
24571 return resultobj;
24572 fail:
24573 return NULL;
24574 }
24575
24576
24577 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24578 PyObject *resultobj;
24579 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24580 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24581 bool result;
24582 PyObject * obj0 = 0 ;
24583 PyObject * obj1 = 0 ;
24584 char *kwnames[] = {
24585 (char *) "self",(char *) "other", NULL
24586 };
24587
24588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24590 if (SWIG_arg_fail(1)) SWIG_fail;
24591 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24592 if (SWIG_arg_fail(2)) SWIG_fail;
24593 {
24594 PyThreadState* __tstate = wxPyBeginAllowThreads();
24595 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24596
24597 wxPyEndAllowThreads(__tstate);
24598 if (PyErr_Occurred()) SWIG_fail;
24599 }
24600 {
24601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24602 }
24603 return resultobj;
24604 fail:
24605 return NULL;
24606 }
24607
24608
24609 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24610 PyObject *resultobj;
24611 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24612 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24613 bool result;
24614 PyObject * obj0 = 0 ;
24615 PyObject * obj1 = 0 ;
24616 char *kwnames[] = {
24617 (char *) "self",(char *) "other", NULL
24618 };
24619
24620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24622 if (SWIG_arg_fail(1)) SWIG_fail;
24623 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24624 if (SWIG_arg_fail(2)) SWIG_fail;
24625 {
24626 PyThreadState* __tstate = wxPyBeginAllowThreads();
24627 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24628
24629 wxPyEndAllowThreads(__tstate);
24630 if (PyErr_Occurred()) SWIG_fail;
24631 }
24632 {
24633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24634 }
24635 return resultobj;
24636 fail:
24637 return NULL;
24638 }
24639
24640
24641 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24642 PyObject *resultobj;
24643 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24644 bool result;
24645 PyObject * obj0 = 0 ;
24646 char *kwnames[] = {
24647 (char *) "self", NULL
24648 };
24649
24650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24652 if (SWIG_arg_fail(1)) SWIG_fail;
24653 {
24654 PyThreadState* __tstate = wxPyBeginAllowThreads();
24655 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24656
24657 wxPyEndAllowThreads(__tstate);
24658 if (PyErr_Occurred()) SWIG_fail;
24659 }
24660 {
24661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24662 }
24663 return resultobj;
24664 fail:
24665 return NULL;
24666 }
24667
24668
24669 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24670 PyObject *resultobj;
24671 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24672 bool result;
24673 PyObject * obj0 = 0 ;
24674 char *kwnames[] = {
24675 (char *) "self", NULL
24676 };
24677
24678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24680 if (SWIG_arg_fail(1)) SWIG_fail;
24681 {
24682 PyThreadState* __tstate = wxPyBeginAllowThreads();
24683 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24684
24685 wxPyEndAllowThreads(__tstate);
24686 if (PyErr_Occurred()) SWIG_fail;
24687 }
24688 {
24689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24690 }
24691 return resultobj;
24692 fail:
24693 return NULL;
24694 }
24695
24696
24697 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24698 PyObject *resultobj;
24699 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24700 bool result;
24701 PyObject * obj0 = 0 ;
24702 char *kwnames[] = {
24703 (char *) "self", NULL
24704 };
24705
24706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24708 if (SWIG_arg_fail(1)) SWIG_fail;
24709 {
24710 PyThreadState* __tstate = wxPyBeginAllowThreads();
24711 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24712
24713 wxPyEndAllowThreads(__tstate);
24714 if (PyErr_Occurred()) SWIG_fail;
24715 }
24716 {
24717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24718 }
24719 return resultobj;
24720 fail:
24721 return NULL;
24722 }
24723
24724
24725 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24726 PyObject *resultobj;
24727 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24728 wxTimeSpan *arg2 = 0 ;
24729 bool result;
24730 PyObject * obj0 = 0 ;
24731 PyObject * obj1 = 0 ;
24732 char *kwnames[] = {
24733 (char *) "self",(char *) "ts", NULL
24734 };
24735
24736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24738 if (SWIG_arg_fail(1)) SWIG_fail;
24739 {
24740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24741 if (SWIG_arg_fail(2)) SWIG_fail;
24742 if (arg2 == NULL) {
24743 SWIG_null_ref("wxTimeSpan");
24744 }
24745 if (SWIG_arg_fail(2)) SWIG_fail;
24746 }
24747 {
24748 PyThreadState* __tstate = wxPyBeginAllowThreads();
24749 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24750
24751 wxPyEndAllowThreads(__tstate);
24752 if (PyErr_Occurred()) SWIG_fail;
24753 }
24754 {
24755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24756 }
24757 return resultobj;
24758 fail:
24759 return NULL;
24760 }
24761
24762
24763 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24764 PyObject *resultobj;
24765 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24766 wxTimeSpan *arg2 = 0 ;
24767 bool result;
24768 PyObject * obj0 = 0 ;
24769 PyObject * obj1 = 0 ;
24770 char *kwnames[] = {
24771 (char *) "self",(char *) "ts", NULL
24772 };
24773
24774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24776 if (SWIG_arg_fail(1)) SWIG_fail;
24777 {
24778 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24779 if (SWIG_arg_fail(2)) SWIG_fail;
24780 if (arg2 == NULL) {
24781 SWIG_null_ref("wxTimeSpan");
24782 }
24783 if (SWIG_arg_fail(2)) SWIG_fail;
24784 }
24785 {
24786 PyThreadState* __tstate = wxPyBeginAllowThreads();
24787 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24788
24789 wxPyEndAllowThreads(__tstate);
24790 if (PyErr_Occurred()) SWIG_fail;
24791 }
24792 {
24793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24794 }
24795 return resultobj;
24796 fail:
24797 return NULL;
24798 }
24799
24800
24801 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24802 PyObject *resultobj;
24803 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24804 wxTimeSpan *arg2 = 0 ;
24805 bool result;
24806 PyObject * obj0 = 0 ;
24807 PyObject * obj1 = 0 ;
24808 char *kwnames[] = {
24809 (char *) "self",(char *) "t", NULL
24810 };
24811
24812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24814 if (SWIG_arg_fail(1)) SWIG_fail;
24815 {
24816 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24817 if (SWIG_arg_fail(2)) SWIG_fail;
24818 if (arg2 == NULL) {
24819 SWIG_null_ref("wxTimeSpan");
24820 }
24821 if (SWIG_arg_fail(2)) SWIG_fail;
24822 }
24823 {
24824 PyThreadState* __tstate = wxPyBeginAllowThreads();
24825 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24826
24827 wxPyEndAllowThreads(__tstate);
24828 if (PyErr_Occurred()) SWIG_fail;
24829 }
24830 {
24831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24832 }
24833 return resultobj;
24834 fail:
24835 return NULL;
24836 }
24837
24838
24839 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24840 PyObject *resultobj;
24841 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24842 int result;
24843 PyObject * obj0 = 0 ;
24844 char *kwnames[] = {
24845 (char *) "self", NULL
24846 };
24847
24848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24850 if (SWIG_arg_fail(1)) SWIG_fail;
24851 {
24852 PyThreadState* __tstate = wxPyBeginAllowThreads();
24853 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24854
24855 wxPyEndAllowThreads(__tstate);
24856 if (PyErr_Occurred()) SWIG_fail;
24857 }
24858 {
24859 resultobj = SWIG_From_int((int)(result));
24860 }
24861 return resultobj;
24862 fail:
24863 return NULL;
24864 }
24865
24866
24867 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24868 PyObject *resultobj;
24869 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24870 int result;
24871 PyObject * obj0 = 0 ;
24872 char *kwnames[] = {
24873 (char *) "self", NULL
24874 };
24875
24876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24878 if (SWIG_arg_fail(1)) SWIG_fail;
24879 {
24880 PyThreadState* __tstate = wxPyBeginAllowThreads();
24881 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24882
24883 wxPyEndAllowThreads(__tstate);
24884 if (PyErr_Occurred()) SWIG_fail;
24885 }
24886 {
24887 resultobj = SWIG_From_int((int)(result));
24888 }
24889 return resultobj;
24890 fail:
24891 return NULL;
24892 }
24893
24894
24895 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
24896 PyObject *resultobj;
24897 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24898 int result;
24899 PyObject * obj0 = 0 ;
24900 char *kwnames[] = {
24901 (char *) "self", NULL
24902 };
24903
24904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
24905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24906 if (SWIG_arg_fail(1)) SWIG_fail;
24907 {
24908 PyThreadState* __tstate = wxPyBeginAllowThreads();
24909 result = (int)((wxTimeSpan const *)arg1)->GetHours();
24910
24911 wxPyEndAllowThreads(__tstate);
24912 if (PyErr_Occurred()) SWIG_fail;
24913 }
24914 {
24915 resultobj = SWIG_From_int((int)(result));
24916 }
24917 return resultobj;
24918 fail:
24919 return NULL;
24920 }
24921
24922
24923 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
24924 PyObject *resultobj;
24925 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24926 int result;
24927 PyObject * obj0 = 0 ;
24928 char *kwnames[] = {
24929 (char *) "self", NULL
24930 };
24931
24932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
24933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24934 if (SWIG_arg_fail(1)) SWIG_fail;
24935 {
24936 PyThreadState* __tstate = wxPyBeginAllowThreads();
24937 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
24938
24939 wxPyEndAllowThreads(__tstate);
24940 if (PyErr_Occurred()) SWIG_fail;
24941 }
24942 {
24943 resultobj = SWIG_From_int((int)(result));
24944 }
24945 return resultobj;
24946 fail:
24947 return NULL;
24948 }
24949
24950
24951 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
24952 PyObject *resultobj;
24953 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24954 wxLongLong result;
24955 PyObject * obj0 = 0 ;
24956 char *kwnames[] = {
24957 (char *) "self", NULL
24958 };
24959
24960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
24961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24962 if (SWIG_arg_fail(1)) SWIG_fail;
24963 {
24964 PyThreadState* __tstate = wxPyBeginAllowThreads();
24965 result = ((wxTimeSpan const *)arg1)->GetSeconds();
24966
24967 wxPyEndAllowThreads(__tstate);
24968 if (PyErr_Occurred()) SWIG_fail;
24969 }
24970 {
24971 PyObject *hi, *lo, *shifter, *shifted;
24972 hi = PyLong_FromLong( (&result)->GetHi() );
24973 lo = PyLong_FromLong( (&result)->GetLo() );
24974 shifter = PyLong_FromLong(32);
24975 shifted = PyNumber_Lshift(hi, shifter);
24976 resultobj = PyNumber_Or(shifted, lo);
24977 Py_DECREF(hi);
24978 Py_DECREF(lo);
24979 Py_DECREF(shifter);
24980 Py_DECREF(shifted);
24981 }
24982 return resultobj;
24983 fail:
24984 return NULL;
24985 }
24986
24987
24988 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
24989 PyObject *resultobj;
24990 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24991 wxLongLong result;
24992 PyObject * obj0 = 0 ;
24993 char *kwnames[] = {
24994 (char *) "self", NULL
24995 };
24996
24997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
24998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24999 if (SWIG_arg_fail(1)) SWIG_fail;
25000 {
25001 PyThreadState* __tstate = wxPyBeginAllowThreads();
25002 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25003
25004 wxPyEndAllowThreads(__tstate);
25005 if (PyErr_Occurred()) SWIG_fail;
25006 }
25007 {
25008 PyObject *hi, *lo, *shifter, *shifted;
25009 hi = PyLong_FromLong( (&result)->GetHi() );
25010 lo = PyLong_FromLong( (&result)->GetLo() );
25011 shifter = PyLong_FromLong(32);
25012 shifted = PyNumber_Lshift(hi, shifter);
25013 resultobj = PyNumber_Or(shifted, lo);
25014 Py_DECREF(hi);
25015 Py_DECREF(lo);
25016 Py_DECREF(shifter);
25017 Py_DECREF(shifted);
25018 }
25019 return resultobj;
25020 fail:
25021 return NULL;
25022 }
25023
25024
25025 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25026 PyObject *resultobj;
25027 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25028 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25029 wxString *arg2 = (wxString *) &arg2_defvalue ;
25030 wxString result;
25031 bool temp2 = false ;
25032 PyObject * obj0 = 0 ;
25033 PyObject * obj1 = 0 ;
25034 char *kwnames[] = {
25035 (char *) "self",(char *) "format", NULL
25036 };
25037
25038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25040 if (SWIG_arg_fail(1)) SWIG_fail;
25041 if (obj1) {
25042 {
25043 arg2 = wxString_in_helper(obj1);
25044 if (arg2 == NULL) SWIG_fail;
25045 temp2 = true;
25046 }
25047 }
25048 {
25049 PyThreadState* __tstate = wxPyBeginAllowThreads();
25050 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25051
25052 wxPyEndAllowThreads(__tstate);
25053 if (PyErr_Occurred()) SWIG_fail;
25054 }
25055 {
25056 #if wxUSE_UNICODE
25057 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25058 #else
25059 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25060 #endif
25061 }
25062 {
25063 if (temp2)
25064 delete arg2;
25065 }
25066 return resultobj;
25067 fail:
25068 {
25069 if (temp2)
25070 delete arg2;
25071 }
25072 return NULL;
25073 }
25074
25075
25076 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25077 PyObject *obj;
25078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25079 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25080 Py_INCREF(obj);
25081 return Py_BuildValue((char *)"");
25082 }
25083 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25084 PyObject *resultobj;
25085 int arg1 = (int) 0 ;
25086 int arg2 = (int) 0 ;
25087 int arg3 = (int) 0 ;
25088 int arg4 = (int) 0 ;
25089 wxDateSpan *result;
25090 PyObject * obj0 = 0 ;
25091 PyObject * obj1 = 0 ;
25092 PyObject * obj2 = 0 ;
25093 PyObject * obj3 = 0 ;
25094 char *kwnames[] = {
25095 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25096 };
25097
25098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25099 if (obj0) {
25100 {
25101 arg1 = (int)(SWIG_As_int(obj0));
25102 if (SWIG_arg_fail(1)) SWIG_fail;
25103 }
25104 }
25105 if (obj1) {
25106 {
25107 arg2 = (int)(SWIG_As_int(obj1));
25108 if (SWIG_arg_fail(2)) SWIG_fail;
25109 }
25110 }
25111 if (obj2) {
25112 {
25113 arg3 = (int)(SWIG_As_int(obj2));
25114 if (SWIG_arg_fail(3)) SWIG_fail;
25115 }
25116 }
25117 if (obj3) {
25118 {
25119 arg4 = (int)(SWIG_As_int(obj3));
25120 if (SWIG_arg_fail(4)) SWIG_fail;
25121 }
25122 }
25123 {
25124 PyThreadState* __tstate = wxPyBeginAllowThreads();
25125 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25126
25127 wxPyEndAllowThreads(__tstate);
25128 if (PyErr_Occurred()) SWIG_fail;
25129 }
25130 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25131 return resultobj;
25132 fail:
25133 return NULL;
25134 }
25135
25136
25137 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25138 PyObject *resultobj;
25139 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25140 PyObject * obj0 = 0 ;
25141 char *kwnames[] = {
25142 (char *) "self", NULL
25143 };
25144
25145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25147 if (SWIG_arg_fail(1)) SWIG_fail;
25148 {
25149 PyThreadState* __tstate = wxPyBeginAllowThreads();
25150 delete arg1;
25151
25152 wxPyEndAllowThreads(__tstate);
25153 if (PyErr_Occurred()) SWIG_fail;
25154 }
25155 Py_INCREF(Py_None); resultobj = Py_None;
25156 return resultobj;
25157 fail:
25158 return NULL;
25159 }
25160
25161
25162 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25163 PyObject *resultobj;
25164 int arg1 ;
25165 wxDateSpan result;
25166 PyObject * obj0 = 0 ;
25167 char *kwnames[] = {
25168 (char *) "days", NULL
25169 };
25170
25171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25172 {
25173 arg1 = (int)(SWIG_As_int(obj0));
25174 if (SWIG_arg_fail(1)) SWIG_fail;
25175 }
25176 {
25177 PyThreadState* __tstate = wxPyBeginAllowThreads();
25178 result = wxDateSpan::Days(arg1);
25179
25180 wxPyEndAllowThreads(__tstate);
25181 if (PyErr_Occurred()) SWIG_fail;
25182 }
25183 {
25184 wxDateSpan * resultptr;
25185 resultptr = new wxDateSpan((wxDateSpan &)(result));
25186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25187 }
25188 return resultobj;
25189 fail:
25190 return NULL;
25191 }
25192
25193
25194 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25195 PyObject *resultobj;
25196 wxDateSpan result;
25197 char *kwnames[] = {
25198 NULL
25199 };
25200
25201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25202 {
25203 PyThreadState* __tstate = wxPyBeginAllowThreads();
25204 result = wxDateSpan::Day();
25205
25206 wxPyEndAllowThreads(__tstate);
25207 if (PyErr_Occurred()) SWIG_fail;
25208 }
25209 {
25210 wxDateSpan * resultptr;
25211 resultptr = new wxDateSpan((wxDateSpan &)(result));
25212 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25213 }
25214 return resultobj;
25215 fail:
25216 return NULL;
25217 }
25218
25219
25220 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25221 PyObject *resultobj;
25222 int arg1 ;
25223 wxDateSpan result;
25224 PyObject * obj0 = 0 ;
25225 char *kwnames[] = {
25226 (char *) "weeks", NULL
25227 };
25228
25229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25230 {
25231 arg1 = (int)(SWIG_As_int(obj0));
25232 if (SWIG_arg_fail(1)) SWIG_fail;
25233 }
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 result = wxDateSpan::Weeks(arg1);
25237
25238 wxPyEndAllowThreads(__tstate);
25239 if (PyErr_Occurred()) SWIG_fail;
25240 }
25241 {
25242 wxDateSpan * resultptr;
25243 resultptr = new wxDateSpan((wxDateSpan &)(result));
25244 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25245 }
25246 return resultobj;
25247 fail:
25248 return NULL;
25249 }
25250
25251
25252 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25253 PyObject *resultobj;
25254 wxDateSpan result;
25255 char *kwnames[] = {
25256 NULL
25257 };
25258
25259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25260 {
25261 PyThreadState* __tstate = wxPyBeginAllowThreads();
25262 result = wxDateSpan::Week();
25263
25264 wxPyEndAllowThreads(__tstate);
25265 if (PyErr_Occurred()) SWIG_fail;
25266 }
25267 {
25268 wxDateSpan * resultptr;
25269 resultptr = new wxDateSpan((wxDateSpan &)(result));
25270 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25271 }
25272 return resultobj;
25273 fail:
25274 return NULL;
25275 }
25276
25277
25278 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25279 PyObject *resultobj;
25280 int arg1 ;
25281 wxDateSpan result;
25282 PyObject * obj0 = 0 ;
25283 char *kwnames[] = {
25284 (char *) "mon", NULL
25285 };
25286
25287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25288 {
25289 arg1 = (int)(SWIG_As_int(obj0));
25290 if (SWIG_arg_fail(1)) SWIG_fail;
25291 }
25292 {
25293 PyThreadState* __tstate = wxPyBeginAllowThreads();
25294 result = wxDateSpan::Months(arg1);
25295
25296 wxPyEndAllowThreads(__tstate);
25297 if (PyErr_Occurred()) SWIG_fail;
25298 }
25299 {
25300 wxDateSpan * resultptr;
25301 resultptr = new wxDateSpan((wxDateSpan &)(result));
25302 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25303 }
25304 return resultobj;
25305 fail:
25306 return NULL;
25307 }
25308
25309
25310 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25311 PyObject *resultobj;
25312 wxDateSpan result;
25313 char *kwnames[] = {
25314 NULL
25315 };
25316
25317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25318 {
25319 PyThreadState* __tstate = wxPyBeginAllowThreads();
25320 result = wxDateSpan::Month();
25321
25322 wxPyEndAllowThreads(__tstate);
25323 if (PyErr_Occurred()) SWIG_fail;
25324 }
25325 {
25326 wxDateSpan * resultptr;
25327 resultptr = new wxDateSpan((wxDateSpan &)(result));
25328 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25329 }
25330 return resultobj;
25331 fail:
25332 return NULL;
25333 }
25334
25335
25336 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25337 PyObject *resultobj;
25338 int arg1 ;
25339 wxDateSpan result;
25340 PyObject * obj0 = 0 ;
25341 char *kwnames[] = {
25342 (char *) "years", NULL
25343 };
25344
25345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25346 {
25347 arg1 = (int)(SWIG_As_int(obj0));
25348 if (SWIG_arg_fail(1)) SWIG_fail;
25349 }
25350 {
25351 PyThreadState* __tstate = wxPyBeginAllowThreads();
25352 result = wxDateSpan::Years(arg1);
25353
25354 wxPyEndAllowThreads(__tstate);
25355 if (PyErr_Occurred()) SWIG_fail;
25356 }
25357 {
25358 wxDateSpan * resultptr;
25359 resultptr = new wxDateSpan((wxDateSpan &)(result));
25360 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25361 }
25362 return resultobj;
25363 fail:
25364 return NULL;
25365 }
25366
25367
25368 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25369 PyObject *resultobj;
25370 wxDateSpan result;
25371 char *kwnames[] = {
25372 NULL
25373 };
25374
25375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25376 {
25377 PyThreadState* __tstate = wxPyBeginAllowThreads();
25378 result = wxDateSpan::Year();
25379
25380 wxPyEndAllowThreads(__tstate);
25381 if (PyErr_Occurred()) SWIG_fail;
25382 }
25383 {
25384 wxDateSpan * resultptr;
25385 resultptr = new wxDateSpan((wxDateSpan &)(result));
25386 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25387 }
25388 return resultobj;
25389 fail:
25390 return NULL;
25391 }
25392
25393
25394 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25395 PyObject *resultobj;
25396 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25397 int arg2 ;
25398 wxDateSpan *result;
25399 PyObject * obj0 = 0 ;
25400 PyObject * obj1 = 0 ;
25401 char *kwnames[] = {
25402 (char *) "self",(char *) "n", NULL
25403 };
25404
25405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25407 if (SWIG_arg_fail(1)) SWIG_fail;
25408 {
25409 arg2 = (int)(SWIG_As_int(obj1));
25410 if (SWIG_arg_fail(2)) SWIG_fail;
25411 }
25412 {
25413 PyThreadState* __tstate = wxPyBeginAllowThreads();
25414 {
25415 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25416 result = (wxDateSpan *) &_result_ref;
25417 }
25418
25419 wxPyEndAllowThreads(__tstate);
25420 if (PyErr_Occurred()) SWIG_fail;
25421 }
25422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25423 return resultobj;
25424 fail:
25425 return NULL;
25426 }
25427
25428
25429 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25430 PyObject *resultobj;
25431 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25432 int arg2 ;
25433 wxDateSpan *result;
25434 PyObject * obj0 = 0 ;
25435 PyObject * obj1 = 0 ;
25436 char *kwnames[] = {
25437 (char *) "self",(char *) "n", NULL
25438 };
25439
25440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25442 if (SWIG_arg_fail(1)) SWIG_fail;
25443 {
25444 arg2 = (int)(SWIG_As_int(obj1));
25445 if (SWIG_arg_fail(2)) SWIG_fail;
25446 }
25447 {
25448 PyThreadState* __tstate = wxPyBeginAllowThreads();
25449 {
25450 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25451 result = (wxDateSpan *) &_result_ref;
25452 }
25453
25454 wxPyEndAllowThreads(__tstate);
25455 if (PyErr_Occurred()) SWIG_fail;
25456 }
25457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25458 return resultobj;
25459 fail:
25460 return NULL;
25461 }
25462
25463
25464 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25465 PyObject *resultobj;
25466 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25467 int arg2 ;
25468 wxDateSpan *result;
25469 PyObject * obj0 = 0 ;
25470 PyObject * obj1 = 0 ;
25471 char *kwnames[] = {
25472 (char *) "self",(char *) "n", NULL
25473 };
25474
25475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25477 if (SWIG_arg_fail(1)) SWIG_fail;
25478 {
25479 arg2 = (int)(SWIG_As_int(obj1));
25480 if (SWIG_arg_fail(2)) SWIG_fail;
25481 }
25482 {
25483 PyThreadState* __tstate = wxPyBeginAllowThreads();
25484 {
25485 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25486 result = (wxDateSpan *) &_result_ref;
25487 }
25488
25489 wxPyEndAllowThreads(__tstate);
25490 if (PyErr_Occurred()) SWIG_fail;
25491 }
25492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25493 return resultobj;
25494 fail:
25495 return NULL;
25496 }
25497
25498
25499 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25500 PyObject *resultobj;
25501 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25502 int arg2 ;
25503 wxDateSpan *result;
25504 PyObject * obj0 = 0 ;
25505 PyObject * obj1 = 0 ;
25506 char *kwnames[] = {
25507 (char *) "self",(char *) "n", NULL
25508 };
25509
25510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25512 if (SWIG_arg_fail(1)) SWIG_fail;
25513 {
25514 arg2 = (int)(SWIG_As_int(obj1));
25515 if (SWIG_arg_fail(2)) SWIG_fail;
25516 }
25517 {
25518 PyThreadState* __tstate = wxPyBeginAllowThreads();
25519 {
25520 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25521 result = (wxDateSpan *) &_result_ref;
25522 }
25523
25524 wxPyEndAllowThreads(__tstate);
25525 if (PyErr_Occurred()) SWIG_fail;
25526 }
25527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25528 return resultobj;
25529 fail:
25530 return NULL;
25531 }
25532
25533
25534 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25535 PyObject *resultobj;
25536 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25537 int result;
25538 PyObject * obj0 = 0 ;
25539 char *kwnames[] = {
25540 (char *) "self", NULL
25541 };
25542
25543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25545 if (SWIG_arg_fail(1)) SWIG_fail;
25546 {
25547 PyThreadState* __tstate = wxPyBeginAllowThreads();
25548 result = (int)((wxDateSpan const *)arg1)->GetYears();
25549
25550 wxPyEndAllowThreads(__tstate);
25551 if (PyErr_Occurred()) SWIG_fail;
25552 }
25553 {
25554 resultobj = SWIG_From_int((int)(result));
25555 }
25556 return resultobj;
25557 fail:
25558 return NULL;
25559 }
25560
25561
25562 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25563 PyObject *resultobj;
25564 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25565 int result;
25566 PyObject * obj0 = 0 ;
25567 char *kwnames[] = {
25568 (char *) "self", NULL
25569 };
25570
25571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25573 if (SWIG_arg_fail(1)) SWIG_fail;
25574 {
25575 PyThreadState* __tstate = wxPyBeginAllowThreads();
25576 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25577
25578 wxPyEndAllowThreads(__tstate);
25579 if (PyErr_Occurred()) SWIG_fail;
25580 }
25581 {
25582 resultobj = SWIG_From_int((int)(result));
25583 }
25584 return resultobj;
25585 fail:
25586 return NULL;
25587 }
25588
25589
25590 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25591 PyObject *resultobj;
25592 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25593 int result;
25594 PyObject * obj0 = 0 ;
25595 char *kwnames[] = {
25596 (char *) "self", NULL
25597 };
25598
25599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25601 if (SWIG_arg_fail(1)) SWIG_fail;
25602 {
25603 PyThreadState* __tstate = wxPyBeginAllowThreads();
25604 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25605
25606 wxPyEndAllowThreads(__tstate);
25607 if (PyErr_Occurred()) SWIG_fail;
25608 }
25609 {
25610 resultobj = SWIG_From_int((int)(result));
25611 }
25612 return resultobj;
25613 fail:
25614 return NULL;
25615 }
25616
25617
25618 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25619 PyObject *resultobj;
25620 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25621 int result;
25622 PyObject * obj0 = 0 ;
25623 char *kwnames[] = {
25624 (char *) "self", NULL
25625 };
25626
25627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25629 if (SWIG_arg_fail(1)) SWIG_fail;
25630 {
25631 PyThreadState* __tstate = wxPyBeginAllowThreads();
25632 result = (int)((wxDateSpan const *)arg1)->GetDays();
25633
25634 wxPyEndAllowThreads(__tstate);
25635 if (PyErr_Occurred()) SWIG_fail;
25636 }
25637 {
25638 resultobj = SWIG_From_int((int)(result));
25639 }
25640 return resultobj;
25641 fail:
25642 return NULL;
25643 }
25644
25645
25646 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25647 PyObject *resultobj;
25648 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25649 int result;
25650 PyObject * obj0 = 0 ;
25651 char *kwnames[] = {
25652 (char *) "self", NULL
25653 };
25654
25655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25657 if (SWIG_arg_fail(1)) SWIG_fail;
25658 {
25659 PyThreadState* __tstate = wxPyBeginAllowThreads();
25660 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25661
25662 wxPyEndAllowThreads(__tstate);
25663 if (PyErr_Occurred()) SWIG_fail;
25664 }
25665 {
25666 resultobj = SWIG_From_int((int)(result));
25667 }
25668 return resultobj;
25669 fail:
25670 return NULL;
25671 }
25672
25673
25674 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25675 PyObject *resultobj;
25676 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25677 wxDateSpan *arg2 = 0 ;
25678 wxDateSpan *result;
25679 PyObject * obj0 = 0 ;
25680 PyObject * obj1 = 0 ;
25681 char *kwnames[] = {
25682 (char *) "self",(char *) "other", NULL
25683 };
25684
25685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25687 if (SWIG_arg_fail(1)) SWIG_fail;
25688 {
25689 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25690 if (SWIG_arg_fail(2)) SWIG_fail;
25691 if (arg2 == NULL) {
25692 SWIG_null_ref("wxDateSpan");
25693 }
25694 if (SWIG_arg_fail(2)) SWIG_fail;
25695 }
25696 {
25697 PyThreadState* __tstate = wxPyBeginAllowThreads();
25698 {
25699 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25700 result = (wxDateSpan *) &_result_ref;
25701 }
25702
25703 wxPyEndAllowThreads(__tstate);
25704 if (PyErr_Occurred()) SWIG_fail;
25705 }
25706 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25707 return resultobj;
25708 fail:
25709 return NULL;
25710 }
25711
25712
25713 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25714 PyObject *resultobj;
25715 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25716 wxDateSpan *arg2 = 0 ;
25717 wxDateSpan *result;
25718 PyObject * obj0 = 0 ;
25719 PyObject * obj1 = 0 ;
25720 char *kwnames[] = {
25721 (char *) "self",(char *) "other", NULL
25722 };
25723
25724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25726 if (SWIG_arg_fail(1)) SWIG_fail;
25727 {
25728 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25729 if (SWIG_arg_fail(2)) SWIG_fail;
25730 if (arg2 == NULL) {
25731 SWIG_null_ref("wxDateSpan");
25732 }
25733 if (SWIG_arg_fail(2)) SWIG_fail;
25734 }
25735 {
25736 PyThreadState* __tstate = wxPyBeginAllowThreads();
25737 {
25738 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25739 result = (wxDateSpan *) &_result_ref;
25740 }
25741
25742 wxPyEndAllowThreads(__tstate);
25743 if (PyErr_Occurred()) SWIG_fail;
25744 }
25745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25746 return resultobj;
25747 fail:
25748 return NULL;
25749 }
25750
25751
25752 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25753 PyObject *resultobj;
25754 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25755 wxDateSpan *result;
25756 PyObject * obj0 = 0 ;
25757 char *kwnames[] = {
25758 (char *) "self", NULL
25759 };
25760
25761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25763 if (SWIG_arg_fail(1)) SWIG_fail;
25764 {
25765 PyThreadState* __tstate = wxPyBeginAllowThreads();
25766 {
25767 wxDateSpan &_result_ref = (arg1)->Neg();
25768 result = (wxDateSpan *) &_result_ref;
25769 }
25770
25771 wxPyEndAllowThreads(__tstate);
25772 if (PyErr_Occurred()) SWIG_fail;
25773 }
25774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25775 return resultobj;
25776 fail:
25777 return NULL;
25778 }
25779
25780
25781 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25782 PyObject *resultobj;
25783 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25784 int arg2 ;
25785 wxDateSpan *result;
25786 PyObject * obj0 = 0 ;
25787 PyObject * obj1 = 0 ;
25788 char *kwnames[] = {
25789 (char *) "self",(char *) "factor", NULL
25790 };
25791
25792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25794 if (SWIG_arg_fail(1)) SWIG_fail;
25795 {
25796 arg2 = (int)(SWIG_As_int(obj1));
25797 if (SWIG_arg_fail(2)) SWIG_fail;
25798 }
25799 {
25800 PyThreadState* __tstate = wxPyBeginAllowThreads();
25801 {
25802 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25803 result = (wxDateSpan *) &_result_ref;
25804 }
25805
25806 wxPyEndAllowThreads(__tstate);
25807 if (PyErr_Occurred()) SWIG_fail;
25808 }
25809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25810 return resultobj;
25811 fail:
25812 return NULL;
25813 }
25814
25815
25816 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25817 PyObject *resultobj;
25818 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25819 wxDateSpan *arg2 = 0 ;
25820 wxDateSpan *result;
25821 PyObject * obj0 = 0 ;
25822 PyObject * obj1 = 0 ;
25823 char *kwnames[] = {
25824 (char *) "self",(char *) "other", NULL
25825 };
25826
25827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25829 if (SWIG_arg_fail(1)) SWIG_fail;
25830 {
25831 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25832 if (SWIG_arg_fail(2)) SWIG_fail;
25833 if (arg2 == NULL) {
25834 SWIG_null_ref("wxDateSpan");
25835 }
25836 if (SWIG_arg_fail(2)) SWIG_fail;
25837 }
25838 {
25839 PyThreadState* __tstate = wxPyBeginAllowThreads();
25840 {
25841 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25842 result = (wxDateSpan *) &_result_ref;
25843 }
25844
25845 wxPyEndAllowThreads(__tstate);
25846 if (PyErr_Occurred()) SWIG_fail;
25847 }
25848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25849 return resultobj;
25850 fail:
25851 return NULL;
25852 }
25853
25854
25855 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25856 PyObject *resultobj;
25857 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25858 wxDateSpan *arg2 = 0 ;
25859 wxDateSpan *result;
25860 PyObject * obj0 = 0 ;
25861 PyObject * obj1 = 0 ;
25862 char *kwnames[] = {
25863 (char *) "self",(char *) "other", NULL
25864 };
25865
25866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25868 if (SWIG_arg_fail(1)) SWIG_fail;
25869 {
25870 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25871 if (SWIG_arg_fail(2)) SWIG_fail;
25872 if (arg2 == NULL) {
25873 SWIG_null_ref("wxDateSpan");
25874 }
25875 if (SWIG_arg_fail(2)) SWIG_fail;
25876 }
25877 {
25878 PyThreadState* __tstate = wxPyBeginAllowThreads();
25879 {
25880 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25881 result = (wxDateSpan *) &_result_ref;
25882 }
25883
25884 wxPyEndAllowThreads(__tstate);
25885 if (PyErr_Occurred()) SWIG_fail;
25886 }
25887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25888 return resultobj;
25889 fail:
25890 return NULL;
25891 }
25892
25893
25894 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25895 PyObject *resultobj;
25896 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25897 wxDateSpan *result;
25898 PyObject * obj0 = 0 ;
25899 char *kwnames[] = {
25900 (char *) "self", NULL
25901 };
25902
25903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
25904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25905 if (SWIG_arg_fail(1)) SWIG_fail;
25906 {
25907 PyThreadState* __tstate = wxPyBeginAllowThreads();
25908 {
25909 wxDateSpan &_result_ref = (arg1)->operator -();
25910 result = (wxDateSpan *) &_result_ref;
25911 }
25912
25913 wxPyEndAllowThreads(__tstate);
25914 if (PyErr_Occurred()) SWIG_fail;
25915 }
25916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25917 return resultobj;
25918 fail:
25919 return NULL;
25920 }
25921
25922
25923 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25924 PyObject *resultobj;
25925 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25926 int arg2 ;
25927 wxDateSpan *result;
25928 PyObject * obj0 = 0 ;
25929 PyObject * obj1 = 0 ;
25930 char *kwnames[] = {
25931 (char *) "self",(char *) "factor", NULL
25932 };
25933
25934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25936 if (SWIG_arg_fail(1)) SWIG_fail;
25937 {
25938 arg2 = (int)(SWIG_As_int(obj1));
25939 if (SWIG_arg_fail(2)) SWIG_fail;
25940 }
25941 {
25942 PyThreadState* __tstate = wxPyBeginAllowThreads();
25943 {
25944 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
25945 result = (wxDateSpan *) &_result_ref;
25946 }
25947
25948 wxPyEndAllowThreads(__tstate);
25949 if (PyErr_Occurred()) SWIG_fail;
25950 }
25951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25952 return resultobj;
25953 fail:
25954 return NULL;
25955 }
25956
25957
25958 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25959 PyObject *resultobj;
25960 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25961 wxDateSpan *arg2 = 0 ;
25962 wxDateSpan result;
25963 PyObject * obj0 = 0 ;
25964 PyObject * obj1 = 0 ;
25965 char *kwnames[] = {
25966 (char *) "self",(char *) "other", NULL
25967 };
25968
25969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25971 if (SWIG_arg_fail(1)) SWIG_fail;
25972 {
25973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25974 if (SWIG_arg_fail(2)) SWIG_fail;
25975 if (arg2 == NULL) {
25976 SWIG_null_ref("wxDateSpan");
25977 }
25978 if (SWIG_arg_fail(2)) SWIG_fail;
25979 }
25980 {
25981 PyThreadState* __tstate = wxPyBeginAllowThreads();
25982 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
25983
25984 wxPyEndAllowThreads(__tstate);
25985 if (PyErr_Occurred()) SWIG_fail;
25986 }
25987 {
25988 wxDateSpan * resultptr;
25989 resultptr = new wxDateSpan((wxDateSpan &)(result));
25990 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25991 }
25992 return resultobj;
25993 fail:
25994 return NULL;
25995 }
25996
25997
25998 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25999 PyObject *resultobj;
26000 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26001 wxDateSpan *arg2 = 0 ;
26002 wxDateSpan result;
26003 PyObject * obj0 = 0 ;
26004 PyObject * obj1 = 0 ;
26005 char *kwnames[] = {
26006 (char *) "self",(char *) "other", NULL
26007 };
26008
26009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26011 if (SWIG_arg_fail(1)) SWIG_fail;
26012 {
26013 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26014 if (SWIG_arg_fail(2)) SWIG_fail;
26015 if (arg2 == NULL) {
26016 SWIG_null_ref("wxDateSpan");
26017 }
26018 if (SWIG_arg_fail(2)) SWIG_fail;
26019 }
26020 {
26021 PyThreadState* __tstate = wxPyBeginAllowThreads();
26022 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26023
26024 wxPyEndAllowThreads(__tstate);
26025 if (PyErr_Occurred()) SWIG_fail;
26026 }
26027 {
26028 wxDateSpan * resultptr;
26029 resultptr = new wxDateSpan((wxDateSpan &)(result));
26030 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26031 }
26032 return resultobj;
26033 fail:
26034 return NULL;
26035 }
26036
26037
26038 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26039 PyObject *resultobj;
26040 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26041 int arg2 ;
26042 wxDateSpan result;
26043 PyObject * obj0 = 0 ;
26044 PyObject * obj1 = 0 ;
26045 char *kwnames[] = {
26046 (char *) "self",(char *) "n", NULL
26047 };
26048
26049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26051 if (SWIG_arg_fail(1)) SWIG_fail;
26052 {
26053 arg2 = (int)(SWIG_As_int(obj1));
26054 if (SWIG_arg_fail(2)) SWIG_fail;
26055 }
26056 {
26057 PyThreadState* __tstate = wxPyBeginAllowThreads();
26058 result = wxDateSpan___mul__(arg1,arg2);
26059
26060 wxPyEndAllowThreads(__tstate);
26061 if (PyErr_Occurred()) SWIG_fail;
26062 }
26063 {
26064 wxDateSpan * resultptr;
26065 resultptr = new wxDateSpan((wxDateSpan &)(result));
26066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26067 }
26068 return resultobj;
26069 fail:
26070 return NULL;
26071 }
26072
26073
26074 static PyObject *_wrap_DateSpan___rmul__(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 *) "n", NULL
26083 };
26084
26085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",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 result = wxDateSpan___rmul__(arg1,arg2);
26095
26096 wxPyEndAllowThreads(__tstate);
26097 if (PyErr_Occurred()) SWIG_fail;
26098 }
26099 {
26100 wxDateSpan * resultptr;
26101 resultptr = new wxDateSpan((wxDateSpan &)(result));
26102 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26103 }
26104 return resultobj;
26105 fail:
26106 return NULL;
26107 }
26108
26109
26110 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26111 PyObject *resultobj;
26112 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26113 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26114 bool result;
26115 PyObject * obj0 = 0 ;
26116 PyObject * obj1 = 0 ;
26117 char *kwnames[] = {
26118 (char *) "self",(char *) "other", NULL
26119 };
26120
26121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26123 if (SWIG_arg_fail(1)) SWIG_fail;
26124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26125 if (SWIG_arg_fail(2)) SWIG_fail;
26126 {
26127 PyThreadState* __tstate = wxPyBeginAllowThreads();
26128 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26129
26130 wxPyEndAllowThreads(__tstate);
26131 if (PyErr_Occurred()) SWIG_fail;
26132 }
26133 {
26134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26135 }
26136 return resultobj;
26137 fail:
26138 return NULL;
26139 }
26140
26141
26142 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26143 PyObject *resultobj;
26144 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26145 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26146 bool result;
26147 PyObject * obj0 = 0 ;
26148 PyObject * obj1 = 0 ;
26149 char *kwnames[] = {
26150 (char *) "self",(char *) "other", NULL
26151 };
26152
26153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26155 if (SWIG_arg_fail(1)) SWIG_fail;
26156 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26157 if (SWIG_arg_fail(2)) SWIG_fail;
26158 {
26159 PyThreadState* __tstate = wxPyBeginAllowThreads();
26160 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26161
26162 wxPyEndAllowThreads(__tstate);
26163 if (PyErr_Occurred()) SWIG_fail;
26164 }
26165 {
26166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26167 }
26168 return resultobj;
26169 fail:
26170 return NULL;
26171 }
26172
26173
26174 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26175 PyObject *obj;
26176 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26177 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26178 Py_INCREF(obj);
26179 return Py_BuildValue((char *)"");
26180 }
26181 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26182 PyObject *resultobj;
26183 long result;
26184 char *kwnames[] = {
26185 NULL
26186 };
26187
26188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26189 {
26190 PyThreadState* __tstate = wxPyBeginAllowThreads();
26191 result = (long)wxGetLocalTime();
26192
26193 wxPyEndAllowThreads(__tstate);
26194 if (PyErr_Occurred()) SWIG_fail;
26195 }
26196 {
26197 resultobj = SWIG_From_long((long)(result));
26198 }
26199 return resultobj;
26200 fail:
26201 return NULL;
26202 }
26203
26204
26205 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26206 PyObject *resultobj;
26207 long result;
26208 char *kwnames[] = {
26209 NULL
26210 };
26211
26212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26213 {
26214 PyThreadState* __tstate = wxPyBeginAllowThreads();
26215 result = (long)wxGetUTCTime();
26216
26217 wxPyEndAllowThreads(__tstate);
26218 if (PyErr_Occurred()) SWIG_fail;
26219 }
26220 {
26221 resultobj = SWIG_From_long((long)(result));
26222 }
26223 return resultobj;
26224 fail:
26225 return NULL;
26226 }
26227
26228
26229 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26230 PyObject *resultobj;
26231 long result;
26232 char *kwnames[] = {
26233 NULL
26234 };
26235
26236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26237 {
26238 PyThreadState* __tstate = wxPyBeginAllowThreads();
26239 result = (long)wxGetCurrentTime();
26240
26241 wxPyEndAllowThreads(__tstate);
26242 if (PyErr_Occurred()) SWIG_fail;
26243 }
26244 {
26245 resultobj = SWIG_From_long((long)(result));
26246 }
26247 return resultobj;
26248 fail:
26249 return NULL;
26250 }
26251
26252
26253 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26254 PyObject *resultobj;
26255 wxLongLong result;
26256 char *kwnames[] = {
26257 NULL
26258 };
26259
26260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26261 {
26262 PyThreadState* __tstate = wxPyBeginAllowThreads();
26263 result = wxGetLocalTimeMillis();
26264
26265 wxPyEndAllowThreads(__tstate);
26266 if (PyErr_Occurred()) SWIG_fail;
26267 }
26268 {
26269 PyObject *hi, *lo, *shifter, *shifted;
26270 hi = PyLong_FromLong( (&result)->GetHi() );
26271 lo = PyLong_FromLong( (&result)->GetLo() );
26272 shifter = PyLong_FromLong(32);
26273 shifted = PyNumber_Lshift(hi, shifter);
26274 resultobj = PyNumber_Or(shifted, lo);
26275 Py_DECREF(hi);
26276 Py_DECREF(lo);
26277 Py_DECREF(shifter);
26278 Py_DECREF(shifted);
26279 }
26280 return resultobj;
26281 fail:
26282 return NULL;
26283 }
26284
26285
26286 static int _wrap_DefaultDateTime_set(PyObject *) {
26287 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26288 return 1;
26289 }
26290
26291
26292 static PyObject *_wrap_DefaultDateTime_get(void) {
26293 PyObject *pyobj;
26294
26295 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26296 return pyobj;
26297 }
26298
26299
26300 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26301 PyObject *resultobj;
26302 wxDataFormatId arg1 ;
26303 wxDataFormat *result;
26304 PyObject * obj0 = 0 ;
26305 char *kwnames[] = {
26306 (char *) "type", NULL
26307 };
26308
26309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26310 {
26311 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26312 if (SWIG_arg_fail(1)) SWIG_fail;
26313 }
26314 {
26315 PyThreadState* __tstate = wxPyBeginAllowThreads();
26316 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26317
26318 wxPyEndAllowThreads(__tstate);
26319 if (PyErr_Occurred()) SWIG_fail;
26320 }
26321 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26322 return resultobj;
26323 fail:
26324 return NULL;
26325 }
26326
26327
26328 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26329 PyObject *resultobj;
26330 wxString *arg1 = 0 ;
26331 wxDataFormat *result;
26332 bool temp1 = false ;
26333 PyObject * obj0 = 0 ;
26334 char *kwnames[] = {
26335 (char *) "format", NULL
26336 };
26337
26338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26339 {
26340 arg1 = wxString_in_helper(obj0);
26341 if (arg1 == NULL) SWIG_fail;
26342 temp1 = true;
26343 }
26344 {
26345 PyThreadState* __tstate = wxPyBeginAllowThreads();
26346 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26347
26348 wxPyEndAllowThreads(__tstate);
26349 if (PyErr_Occurred()) SWIG_fail;
26350 }
26351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26352 {
26353 if (temp1)
26354 delete arg1;
26355 }
26356 return resultobj;
26357 fail:
26358 {
26359 if (temp1)
26360 delete arg1;
26361 }
26362 return NULL;
26363 }
26364
26365
26366 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26367 PyObject *resultobj;
26368 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26369 PyObject * obj0 = 0 ;
26370 char *kwnames[] = {
26371 (char *) "self", NULL
26372 };
26373
26374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26376 if (SWIG_arg_fail(1)) SWIG_fail;
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 delete arg1;
26380
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 Py_INCREF(Py_None); resultobj = Py_None;
26385 return resultobj;
26386 fail:
26387 return NULL;
26388 }
26389
26390
26391 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26392 PyObject *resultobj;
26393 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26394 wxDataFormatId arg2 ;
26395 bool result;
26396 PyObject * obj0 = 0 ;
26397 PyObject * obj1 = 0 ;
26398
26399 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26401 if (SWIG_arg_fail(1)) SWIG_fail;
26402 {
26403 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26404 if (SWIG_arg_fail(2)) SWIG_fail;
26405 }
26406 {
26407 PyThreadState* __tstate = wxPyBeginAllowThreads();
26408 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26409
26410 wxPyEndAllowThreads(__tstate);
26411 if (PyErr_Occurred()) SWIG_fail;
26412 }
26413 {
26414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26415 }
26416 return resultobj;
26417 fail:
26418 return NULL;
26419 }
26420
26421
26422 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26423 PyObject *resultobj;
26424 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26425 wxDataFormatId arg2 ;
26426 bool result;
26427 PyObject * obj0 = 0 ;
26428 PyObject * obj1 = 0 ;
26429
26430 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26432 if (SWIG_arg_fail(1)) SWIG_fail;
26433 {
26434 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26435 if (SWIG_arg_fail(2)) SWIG_fail;
26436 }
26437 {
26438 PyThreadState* __tstate = wxPyBeginAllowThreads();
26439 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26440
26441 wxPyEndAllowThreads(__tstate);
26442 if (PyErr_Occurred()) SWIG_fail;
26443 }
26444 {
26445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26446 }
26447 return resultobj;
26448 fail:
26449 return NULL;
26450 }
26451
26452
26453 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26454 PyObject *resultobj;
26455 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26456 wxDataFormat *arg2 = 0 ;
26457 bool result;
26458 PyObject * obj0 = 0 ;
26459 PyObject * obj1 = 0 ;
26460
26461 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26463 if (SWIG_arg_fail(1)) SWIG_fail;
26464 {
26465 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26466 if (SWIG_arg_fail(2)) SWIG_fail;
26467 if (arg2 == NULL) {
26468 SWIG_null_ref("wxDataFormat");
26469 }
26470 if (SWIG_arg_fail(2)) SWIG_fail;
26471 }
26472 {
26473 PyThreadState* __tstate = wxPyBeginAllowThreads();
26474 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26475
26476 wxPyEndAllowThreads(__tstate);
26477 if (PyErr_Occurred()) SWIG_fail;
26478 }
26479 {
26480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26481 }
26482 return resultobj;
26483 fail:
26484 return NULL;
26485 }
26486
26487
26488 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26489 int argc;
26490 PyObject *argv[3];
26491 int ii;
26492
26493 argc = PyObject_Length(args);
26494 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26495 argv[ii] = PyTuple_GetItem(args,ii);
26496 }
26497 if (argc == 2) {
26498 int _v;
26499 {
26500 void *ptr;
26501 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26502 _v = 0;
26503 PyErr_Clear();
26504 } else {
26505 _v = 1;
26506 }
26507 }
26508 if (_v) {
26509 {
26510 void *ptr = 0;
26511 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26512 _v = 0;
26513 PyErr_Clear();
26514 } else {
26515 _v = (ptr != 0);
26516 }
26517 }
26518 if (_v) {
26519 return _wrap_DataFormat___eq____SWIG_1(self,args);
26520 }
26521 }
26522 }
26523 if (argc == 2) {
26524 int _v;
26525 {
26526 void *ptr;
26527 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26528 _v = 0;
26529 PyErr_Clear();
26530 } else {
26531 _v = 1;
26532 }
26533 }
26534 if (_v) {
26535 _v = SWIG_Check_int(argv[1]);
26536 if (_v) {
26537 return _wrap_DataFormat___eq____SWIG_0(self,args);
26538 }
26539 }
26540 }
26541
26542 Py_INCREF(Py_NotImplemented);
26543 return Py_NotImplemented;
26544 }
26545
26546
26547 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26548 PyObject *resultobj;
26549 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26550 wxDataFormat *arg2 = 0 ;
26551 bool result;
26552 PyObject * obj0 = 0 ;
26553 PyObject * obj1 = 0 ;
26554
26555 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26557 if (SWIG_arg_fail(1)) SWIG_fail;
26558 {
26559 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26560 if (SWIG_arg_fail(2)) SWIG_fail;
26561 if (arg2 == NULL) {
26562 SWIG_null_ref("wxDataFormat");
26563 }
26564 if (SWIG_arg_fail(2)) SWIG_fail;
26565 }
26566 {
26567 PyThreadState* __tstate = wxPyBeginAllowThreads();
26568 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26569
26570 wxPyEndAllowThreads(__tstate);
26571 if (PyErr_Occurred()) SWIG_fail;
26572 }
26573 {
26574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26575 }
26576 return resultobj;
26577 fail:
26578 return NULL;
26579 }
26580
26581
26582 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26583 int argc;
26584 PyObject *argv[3];
26585 int ii;
26586
26587 argc = PyObject_Length(args);
26588 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26589 argv[ii] = PyTuple_GetItem(args,ii);
26590 }
26591 if (argc == 2) {
26592 int _v;
26593 {
26594 void *ptr;
26595 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26596 _v = 0;
26597 PyErr_Clear();
26598 } else {
26599 _v = 1;
26600 }
26601 }
26602 if (_v) {
26603 {
26604 void *ptr = 0;
26605 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26606 _v = 0;
26607 PyErr_Clear();
26608 } else {
26609 _v = (ptr != 0);
26610 }
26611 }
26612 if (_v) {
26613 return _wrap_DataFormat___ne____SWIG_1(self,args);
26614 }
26615 }
26616 }
26617 if (argc == 2) {
26618 int _v;
26619 {
26620 void *ptr;
26621 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26622 _v = 0;
26623 PyErr_Clear();
26624 } else {
26625 _v = 1;
26626 }
26627 }
26628 if (_v) {
26629 _v = SWIG_Check_int(argv[1]);
26630 if (_v) {
26631 return _wrap_DataFormat___ne____SWIG_0(self,args);
26632 }
26633 }
26634 }
26635
26636 Py_INCREF(Py_NotImplemented);
26637 return Py_NotImplemented;
26638 }
26639
26640
26641 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26642 PyObject *resultobj;
26643 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26644 wxDataFormatId arg2 ;
26645 PyObject * obj0 = 0 ;
26646 PyObject * obj1 = 0 ;
26647 char *kwnames[] = {
26648 (char *) "self",(char *) "format", NULL
26649 };
26650
26651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26653 if (SWIG_arg_fail(1)) SWIG_fail;
26654 {
26655 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26656 if (SWIG_arg_fail(2)) SWIG_fail;
26657 }
26658 {
26659 PyThreadState* __tstate = wxPyBeginAllowThreads();
26660 (arg1)->SetType((wxDataFormatId )arg2);
26661
26662 wxPyEndAllowThreads(__tstate);
26663 if (PyErr_Occurred()) SWIG_fail;
26664 }
26665 Py_INCREF(Py_None); resultobj = Py_None;
26666 return resultobj;
26667 fail:
26668 return NULL;
26669 }
26670
26671
26672 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26673 PyObject *resultobj;
26674 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26675 wxDataFormatId result;
26676 PyObject * obj0 = 0 ;
26677 char *kwnames[] = {
26678 (char *) "self", NULL
26679 };
26680
26681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26683 if (SWIG_arg_fail(1)) SWIG_fail;
26684 {
26685 PyThreadState* __tstate = wxPyBeginAllowThreads();
26686 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26687
26688 wxPyEndAllowThreads(__tstate);
26689 if (PyErr_Occurred()) SWIG_fail;
26690 }
26691 resultobj = SWIG_From_int((result));
26692 return resultobj;
26693 fail:
26694 return NULL;
26695 }
26696
26697
26698 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26699 PyObject *resultobj;
26700 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26701 wxString result;
26702 PyObject * obj0 = 0 ;
26703 char *kwnames[] = {
26704 (char *) "self", NULL
26705 };
26706
26707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26709 if (SWIG_arg_fail(1)) SWIG_fail;
26710 {
26711 PyThreadState* __tstate = wxPyBeginAllowThreads();
26712 result = ((wxDataFormat const *)arg1)->GetId();
26713
26714 wxPyEndAllowThreads(__tstate);
26715 if (PyErr_Occurred()) SWIG_fail;
26716 }
26717 {
26718 #if wxUSE_UNICODE
26719 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26720 #else
26721 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26722 #endif
26723 }
26724 return resultobj;
26725 fail:
26726 return NULL;
26727 }
26728
26729
26730 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26731 PyObject *resultobj;
26732 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26733 wxString *arg2 = 0 ;
26734 bool temp2 = false ;
26735 PyObject * obj0 = 0 ;
26736 PyObject * obj1 = 0 ;
26737 char *kwnames[] = {
26738 (char *) "self",(char *) "format", NULL
26739 };
26740
26741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26743 if (SWIG_arg_fail(1)) SWIG_fail;
26744 {
26745 arg2 = wxString_in_helper(obj1);
26746 if (arg2 == NULL) SWIG_fail;
26747 temp2 = true;
26748 }
26749 {
26750 PyThreadState* __tstate = wxPyBeginAllowThreads();
26751 (arg1)->SetId((wxString const &)*arg2);
26752
26753 wxPyEndAllowThreads(__tstate);
26754 if (PyErr_Occurred()) SWIG_fail;
26755 }
26756 Py_INCREF(Py_None); resultobj = Py_None;
26757 {
26758 if (temp2)
26759 delete arg2;
26760 }
26761 return resultobj;
26762 fail:
26763 {
26764 if (temp2)
26765 delete arg2;
26766 }
26767 return NULL;
26768 }
26769
26770
26771 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26772 PyObject *obj;
26773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26774 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26775 Py_INCREF(obj);
26776 return Py_BuildValue((char *)"");
26777 }
26778 static int _wrap_FormatInvalid_set(PyObject *) {
26779 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26780 return 1;
26781 }
26782
26783
26784 static PyObject *_wrap_FormatInvalid_get(void) {
26785 PyObject *pyobj;
26786
26787 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26788 return pyobj;
26789 }
26790
26791
26792 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26793 PyObject *resultobj;
26794 wxDataObject *arg1 = (wxDataObject *) 0 ;
26795 PyObject * obj0 = 0 ;
26796 char *kwnames[] = {
26797 (char *) "self", NULL
26798 };
26799
26800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26802 if (SWIG_arg_fail(1)) SWIG_fail;
26803 {
26804 PyThreadState* __tstate = wxPyBeginAllowThreads();
26805 delete arg1;
26806
26807 wxPyEndAllowThreads(__tstate);
26808 if (PyErr_Occurred()) SWIG_fail;
26809 }
26810 Py_INCREF(Py_None); resultobj = Py_None;
26811 return resultobj;
26812 fail:
26813 return NULL;
26814 }
26815
26816
26817 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26818 PyObject *resultobj;
26819 wxDataObject *arg1 = (wxDataObject *) 0 ;
26820 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26821 SwigValueWrapper<wxDataFormat > result;
26822 PyObject * obj0 = 0 ;
26823 PyObject * obj1 = 0 ;
26824 char *kwnames[] = {
26825 (char *) "self",(char *) "dir", NULL
26826 };
26827
26828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26830 if (SWIG_arg_fail(1)) SWIG_fail;
26831 if (obj1) {
26832 {
26833 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26834 if (SWIG_arg_fail(2)) SWIG_fail;
26835 }
26836 }
26837 {
26838 PyThreadState* __tstate = wxPyBeginAllowThreads();
26839 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26840
26841 wxPyEndAllowThreads(__tstate);
26842 if (PyErr_Occurred()) SWIG_fail;
26843 }
26844 {
26845 wxDataFormat * resultptr;
26846 resultptr = new wxDataFormat((wxDataFormat &)(result));
26847 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26848 }
26849 return resultobj;
26850 fail:
26851 return NULL;
26852 }
26853
26854
26855 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26856 PyObject *resultobj;
26857 wxDataObject *arg1 = (wxDataObject *) 0 ;
26858 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26859 size_t result;
26860 PyObject * obj0 = 0 ;
26861 PyObject * obj1 = 0 ;
26862 char *kwnames[] = {
26863 (char *) "self",(char *) "dir", NULL
26864 };
26865
26866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26868 if (SWIG_arg_fail(1)) SWIG_fail;
26869 if (obj1) {
26870 {
26871 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26872 if (SWIG_arg_fail(2)) SWIG_fail;
26873 }
26874 }
26875 {
26876 PyThreadState* __tstate = wxPyBeginAllowThreads();
26877 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26878
26879 wxPyEndAllowThreads(__tstate);
26880 if (PyErr_Occurred()) SWIG_fail;
26881 }
26882 {
26883 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26884 }
26885 return resultobj;
26886 fail:
26887 return NULL;
26888 }
26889
26890
26891 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26892 PyObject *resultobj;
26893 wxDataObject *arg1 = (wxDataObject *) 0 ;
26894 wxDataFormat *arg2 = 0 ;
26895 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
26896 bool result;
26897 PyObject * obj0 = 0 ;
26898 PyObject * obj1 = 0 ;
26899 PyObject * obj2 = 0 ;
26900 char *kwnames[] = {
26901 (char *) "self",(char *) "format",(char *) "dir", NULL
26902 };
26903
26904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
26905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26906 if (SWIG_arg_fail(1)) SWIG_fail;
26907 {
26908 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26909 if (SWIG_arg_fail(2)) SWIG_fail;
26910 if (arg2 == NULL) {
26911 SWIG_null_ref("wxDataFormat");
26912 }
26913 if (SWIG_arg_fail(2)) SWIG_fail;
26914 }
26915 if (obj2) {
26916 {
26917 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
26918 if (SWIG_arg_fail(3)) SWIG_fail;
26919 }
26920 }
26921 {
26922 PyThreadState* __tstate = wxPyBeginAllowThreads();
26923 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
26924
26925 wxPyEndAllowThreads(__tstate);
26926 if (PyErr_Occurred()) SWIG_fail;
26927 }
26928 {
26929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26930 }
26931 return resultobj;
26932 fail:
26933 return NULL;
26934 }
26935
26936
26937 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26938 PyObject *resultobj;
26939 wxDataObject *arg1 = (wxDataObject *) 0 ;
26940 wxDataFormat *arg2 = 0 ;
26941 size_t result;
26942 PyObject * obj0 = 0 ;
26943 PyObject * obj1 = 0 ;
26944 char *kwnames[] = {
26945 (char *) "self",(char *) "format", NULL
26946 };
26947
26948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
26949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26950 if (SWIG_arg_fail(1)) SWIG_fail;
26951 {
26952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26953 if (SWIG_arg_fail(2)) SWIG_fail;
26954 if (arg2 == NULL) {
26955 SWIG_null_ref("wxDataFormat");
26956 }
26957 if (SWIG_arg_fail(2)) SWIG_fail;
26958 }
26959 {
26960 PyThreadState* __tstate = wxPyBeginAllowThreads();
26961 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
26962
26963 wxPyEndAllowThreads(__tstate);
26964 if (PyErr_Occurred()) SWIG_fail;
26965 }
26966 {
26967 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26968 }
26969 return resultobj;
26970 fail:
26971 return NULL;
26972 }
26973
26974
26975 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
26976 PyObject *resultobj;
26977 wxDataObject *arg1 = (wxDataObject *) 0 ;
26978 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26979 PyObject *result;
26980 PyObject * obj0 = 0 ;
26981 PyObject * obj1 = 0 ;
26982 char *kwnames[] = {
26983 (char *) "self",(char *) "dir", NULL
26984 };
26985
26986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
26987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26988 if (SWIG_arg_fail(1)) SWIG_fail;
26989 if (obj1) {
26990 {
26991 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26992 if (SWIG_arg_fail(2)) SWIG_fail;
26993 }
26994 }
26995 {
26996 PyThreadState* __tstate = wxPyBeginAllowThreads();
26997 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
26998
26999 wxPyEndAllowThreads(__tstate);
27000 if (PyErr_Occurred()) SWIG_fail;
27001 }
27002 resultobj = result;
27003 return resultobj;
27004 fail:
27005 return NULL;
27006 }
27007
27008
27009 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27010 PyObject *resultobj;
27011 wxDataObject *arg1 = (wxDataObject *) 0 ;
27012 wxDataFormat *arg2 = 0 ;
27013 PyObject *result;
27014 PyObject * obj0 = 0 ;
27015 PyObject * obj1 = 0 ;
27016 char *kwnames[] = {
27017 (char *) "self",(char *) "format", NULL
27018 };
27019
27020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27022 if (SWIG_arg_fail(1)) SWIG_fail;
27023 {
27024 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27025 if (SWIG_arg_fail(2)) SWIG_fail;
27026 if (arg2 == NULL) {
27027 SWIG_null_ref("wxDataFormat");
27028 }
27029 if (SWIG_arg_fail(2)) SWIG_fail;
27030 }
27031 {
27032 PyThreadState* __tstate = wxPyBeginAllowThreads();
27033 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27034
27035 wxPyEndAllowThreads(__tstate);
27036 if (PyErr_Occurred()) SWIG_fail;
27037 }
27038 resultobj = result;
27039 return resultobj;
27040 fail:
27041 return NULL;
27042 }
27043
27044
27045 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27046 PyObject *resultobj;
27047 wxDataObject *arg1 = (wxDataObject *) 0 ;
27048 wxDataFormat *arg2 = 0 ;
27049 PyObject *arg3 = (PyObject *) 0 ;
27050 bool result;
27051 PyObject * obj0 = 0 ;
27052 PyObject * obj1 = 0 ;
27053 PyObject * obj2 = 0 ;
27054 char *kwnames[] = {
27055 (char *) "self",(char *) "format",(char *) "data", NULL
27056 };
27057
27058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27060 if (SWIG_arg_fail(1)) SWIG_fail;
27061 {
27062 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27063 if (SWIG_arg_fail(2)) SWIG_fail;
27064 if (arg2 == NULL) {
27065 SWIG_null_ref("wxDataFormat");
27066 }
27067 if (SWIG_arg_fail(2)) SWIG_fail;
27068 }
27069 arg3 = obj2;
27070 {
27071 PyThreadState* __tstate = wxPyBeginAllowThreads();
27072 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27073
27074 wxPyEndAllowThreads(__tstate);
27075 if (PyErr_Occurred()) SWIG_fail;
27076 }
27077 {
27078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27079 }
27080 return resultobj;
27081 fail:
27082 return NULL;
27083 }
27084
27085
27086 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27087 PyObject *obj;
27088 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27089 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27090 Py_INCREF(obj);
27091 return Py_BuildValue((char *)"");
27092 }
27093 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27094 PyObject *resultobj;
27095 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27096 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27097 wxDataObjectSimple *result;
27098 PyObject * obj0 = 0 ;
27099 char *kwnames[] = {
27100 (char *) "format", NULL
27101 };
27102
27103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27104 if (obj0) {
27105 {
27106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27107 if (SWIG_arg_fail(1)) SWIG_fail;
27108 if (arg1 == NULL) {
27109 SWIG_null_ref("wxDataFormat");
27110 }
27111 if (SWIG_arg_fail(1)) SWIG_fail;
27112 }
27113 }
27114 {
27115 PyThreadState* __tstate = wxPyBeginAllowThreads();
27116 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27117
27118 wxPyEndAllowThreads(__tstate);
27119 if (PyErr_Occurred()) SWIG_fail;
27120 }
27121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27122 return resultobj;
27123 fail:
27124 return NULL;
27125 }
27126
27127
27128 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27129 PyObject *resultobj;
27130 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27131 wxDataFormat *result;
27132 PyObject * obj0 = 0 ;
27133 char *kwnames[] = {
27134 (char *) "self", NULL
27135 };
27136
27137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27139 if (SWIG_arg_fail(1)) SWIG_fail;
27140 {
27141 PyThreadState* __tstate = wxPyBeginAllowThreads();
27142 {
27143 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27144 result = (wxDataFormat *) &_result_ref;
27145 }
27146
27147 wxPyEndAllowThreads(__tstate);
27148 if (PyErr_Occurred()) SWIG_fail;
27149 }
27150 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27151 return resultobj;
27152 fail:
27153 return NULL;
27154 }
27155
27156
27157 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27158 PyObject *resultobj;
27159 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27160 wxDataFormat *arg2 = 0 ;
27161 PyObject * obj0 = 0 ;
27162 PyObject * obj1 = 0 ;
27163 char *kwnames[] = {
27164 (char *) "self",(char *) "format", NULL
27165 };
27166
27167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27169 if (SWIG_arg_fail(1)) SWIG_fail;
27170 {
27171 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27172 if (SWIG_arg_fail(2)) SWIG_fail;
27173 if (arg2 == NULL) {
27174 SWIG_null_ref("wxDataFormat");
27175 }
27176 if (SWIG_arg_fail(2)) SWIG_fail;
27177 }
27178 {
27179 PyThreadState* __tstate = wxPyBeginAllowThreads();
27180 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27181
27182 wxPyEndAllowThreads(__tstate);
27183 if (PyErr_Occurred()) SWIG_fail;
27184 }
27185 Py_INCREF(Py_None); resultobj = Py_None;
27186 return resultobj;
27187 fail:
27188 return NULL;
27189 }
27190
27191
27192 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27193 PyObject *resultobj;
27194 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27195 size_t result;
27196 PyObject * obj0 = 0 ;
27197 char *kwnames[] = {
27198 (char *) "self", NULL
27199 };
27200
27201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27203 if (SWIG_arg_fail(1)) SWIG_fail;
27204 {
27205 PyThreadState* __tstate = wxPyBeginAllowThreads();
27206 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27207
27208 wxPyEndAllowThreads(__tstate);
27209 if (PyErr_Occurred()) SWIG_fail;
27210 }
27211 {
27212 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27213 }
27214 return resultobj;
27215 fail:
27216 return NULL;
27217 }
27218
27219
27220 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27221 PyObject *resultobj;
27222 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27223 PyObject *result;
27224 PyObject * obj0 = 0 ;
27225 char *kwnames[] = {
27226 (char *) "self", NULL
27227 };
27228
27229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27231 if (SWIG_arg_fail(1)) SWIG_fail;
27232 {
27233 PyThreadState* __tstate = wxPyBeginAllowThreads();
27234 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27235
27236 wxPyEndAllowThreads(__tstate);
27237 if (PyErr_Occurred()) SWIG_fail;
27238 }
27239 resultobj = result;
27240 return resultobj;
27241 fail:
27242 return NULL;
27243 }
27244
27245
27246 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27247 PyObject *resultobj;
27248 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27249 PyObject *arg2 = (PyObject *) 0 ;
27250 bool result;
27251 PyObject * obj0 = 0 ;
27252 PyObject * obj1 = 0 ;
27253 char *kwnames[] = {
27254 (char *) "self",(char *) "data", NULL
27255 };
27256
27257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27259 if (SWIG_arg_fail(1)) SWIG_fail;
27260 arg2 = obj1;
27261 {
27262 PyThreadState* __tstate = wxPyBeginAllowThreads();
27263 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27264
27265 wxPyEndAllowThreads(__tstate);
27266 if (PyErr_Occurred()) SWIG_fail;
27267 }
27268 {
27269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27270 }
27271 return resultobj;
27272 fail:
27273 return NULL;
27274 }
27275
27276
27277 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27278 PyObject *obj;
27279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27280 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27281 Py_INCREF(obj);
27282 return Py_BuildValue((char *)"");
27283 }
27284 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27285 PyObject *resultobj;
27286 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27287 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27288 wxPyDataObjectSimple *result;
27289 PyObject * obj0 = 0 ;
27290 char *kwnames[] = {
27291 (char *) "format", NULL
27292 };
27293
27294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27295 if (obj0) {
27296 {
27297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27298 if (SWIG_arg_fail(1)) SWIG_fail;
27299 if (arg1 == NULL) {
27300 SWIG_null_ref("wxDataFormat");
27301 }
27302 if (SWIG_arg_fail(1)) SWIG_fail;
27303 }
27304 }
27305 {
27306 PyThreadState* __tstate = wxPyBeginAllowThreads();
27307 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27308
27309 wxPyEndAllowThreads(__tstate);
27310 if (PyErr_Occurred()) SWIG_fail;
27311 }
27312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27313 return resultobj;
27314 fail:
27315 return NULL;
27316 }
27317
27318
27319 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27320 PyObject *resultobj;
27321 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27322 PyObject *arg2 = (PyObject *) 0 ;
27323 PyObject *arg3 = (PyObject *) 0 ;
27324 PyObject * obj0 = 0 ;
27325 PyObject * obj1 = 0 ;
27326 PyObject * obj2 = 0 ;
27327 char *kwnames[] = {
27328 (char *) "self",(char *) "self",(char *) "_class", NULL
27329 };
27330
27331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27333 if (SWIG_arg_fail(1)) SWIG_fail;
27334 arg2 = obj1;
27335 arg3 = obj2;
27336 {
27337 PyThreadState* __tstate = wxPyBeginAllowThreads();
27338 (arg1)->_setCallbackInfo(arg2,arg3);
27339
27340 wxPyEndAllowThreads(__tstate);
27341 if (PyErr_Occurred()) SWIG_fail;
27342 }
27343 Py_INCREF(Py_None); resultobj = Py_None;
27344 return resultobj;
27345 fail:
27346 return NULL;
27347 }
27348
27349
27350 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27351 PyObject *obj;
27352 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27353 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27354 Py_INCREF(obj);
27355 return Py_BuildValue((char *)"");
27356 }
27357 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27358 PyObject *resultobj;
27359 wxDataObjectComposite *result;
27360 char *kwnames[] = {
27361 NULL
27362 };
27363
27364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27365 {
27366 PyThreadState* __tstate = wxPyBeginAllowThreads();
27367 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27368
27369 wxPyEndAllowThreads(__tstate);
27370 if (PyErr_Occurred()) SWIG_fail;
27371 }
27372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27373 return resultobj;
27374 fail:
27375 return NULL;
27376 }
27377
27378
27379 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27380 PyObject *resultobj;
27381 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27382 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27383 bool arg3 = (bool) false ;
27384 PyObject * obj0 = 0 ;
27385 PyObject * obj1 = 0 ;
27386 PyObject * obj2 = 0 ;
27387 char *kwnames[] = {
27388 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27389 };
27390
27391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27393 if (SWIG_arg_fail(1)) SWIG_fail;
27394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27395 if (SWIG_arg_fail(2)) SWIG_fail;
27396 if (obj2) {
27397 {
27398 arg3 = (bool)(SWIG_As_bool(obj2));
27399 if (SWIG_arg_fail(3)) SWIG_fail;
27400 }
27401 }
27402 {
27403 PyThreadState* __tstate = wxPyBeginAllowThreads();
27404 (arg1)->Add(arg2,arg3);
27405
27406 wxPyEndAllowThreads(__tstate);
27407 if (PyErr_Occurred()) SWIG_fail;
27408 }
27409 Py_INCREF(Py_None); resultobj = Py_None;
27410 return resultobj;
27411 fail:
27412 return NULL;
27413 }
27414
27415
27416 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27417 PyObject *obj;
27418 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27419 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27420 Py_INCREF(obj);
27421 return Py_BuildValue((char *)"");
27422 }
27423 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27424 PyObject *resultobj;
27425 wxString const &arg1_defvalue = wxPyEmptyString ;
27426 wxString *arg1 = (wxString *) &arg1_defvalue ;
27427 wxTextDataObject *result;
27428 bool temp1 = false ;
27429 PyObject * obj0 = 0 ;
27430 char *kwnames[] = {
27431 (char *) "text", NULL
27432 };
27433
27434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27435 if (obj0) {
27436 {
27437 arg1 = wxString_in_helper(obj0);
27438 if (arg1 == NULL) SWIG_fail;
27439 temp1 = true;
27440 }
27441 }
27442 {
27443 PyThreadState* __tstate = wxPyBeginAllowThreads();
27444 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27445
27446 wxPyEndAllowThreads(__tstate);
27447 if (PyErr_Occurred()) SWIG_fail;
27448 }
27449 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27450 {
27451 if (temp1)
27452 delete arg1;
27453 }
27454 return resultobj;
27455 fail:
27456 {
27457 if (temp1)
27458 delete arg1;
27459 }
27460 return NULL;
27461 }
27462
27463
27464 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27465 PyObject *resultobj;
27466 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27467 size_t result;
27468 PyObject * obj0 = 0 ;
27469 char *kwnames[] = {
27470 (char *) "self", NULL
27471 };
27472
27473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27475 if (SWIG_arg_fail(1)) SWIG_fail;
27476 {
27477 PyThreadState* __tstate = wxPyBeginAllowThreads();
27478 result = (size_t)(arg1)->GetTextLength();
27479
27480 wxPyEndAllowThreads(__tstate);
27481 if (PyErr_Occurred()) SWIG_fail;
27482 }
27483 {
27484 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27485 }
27486 return resultobj;
27487 fail:
27488 return NULL;
27489 }
27490
27491
27492 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27493 PyObject *resultobj;
27494 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27495 wxString result;
27496 PyObject * obj0 = 0 ;
27497 char *kwnames[] = {
27498 (char *) "self", NULL
27499 };
27500
27501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27503 if (SWIG_arg_fail(1)) SWIG_fail;
27504 {
27505 PyThreadState* __tstate = wxPyBeginAllowThreads();
27506 result = (arg1)->GetText();
27507
27508 wxPyEndAllowThreads(__tstate);
27509 if (PyErr_Occurred()) SWIG_fail;
27510 }
27511 {
27512 #if wxUSE_UNICODE
27513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27514 #else
27515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27516 #endif
27517 }
27518 return resultobj;
27519 fail:
27520 return NULL;
27521 }
27522
27523
27524 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27525 PyObject *resultobj;
27526 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27527 wxString *arg2 = 0 ;
27528 bool temp2 = false ;
27529 PyObject * obj0 = 0 ;
27530 PyObject * obj1 = 0 ;
27531 char *kwnames[] = {
27532 (char *) "self",(char *) "text", NULL
27533 };
27534
27535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27537 if (SWIG_arg_fail(1)) SWIG_fail;
27538 {
27539 arg2 = wxString_in_helper(obj1);
27540 if (arg2 == NULL) SWIG_fail;
27541 temp2 = true;
27542 }
27543 {
27544 PyThreadState* __tstate = wxPyBeginAllowThreads();
27545 (arg1)->SetText((wxString const &)*arg2);
27546
27547 wxPyEndAllowThreads(__tstate);
27548 if (PyErr_Occurred()) SWIG_fail;
27549 }
27550 Py_INCREF(Py_None); resultobj = Py_None;
27551 {
27552 if (temp2)
27553 delete arg2;
27554 }
27555 return resultobj;
27556 fail:
27557 {
27558 if (temp2)
27559 delete arg2;
27560 }
27561 return NULL;
27562 }
27563
27564
27565 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27566 PyObject *obj;
27567 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27568 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27569 Py_INCREF(obj);
27570 return Py_BuildValue((char *)"");
27571 }
27572 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27573 PyObject *resultobj;
27574 wxString const &arg1_defvalue = wxPyEmptyString ;
27575 wxString *arg1 = (wxString *) &arg1_defvalue ;
27576 wxPyTextDataObject *result;
27577 bool temp1 = false ;
27578 PyObject * obj0 = 0 ;
27579 char *kwnames[] = {
27580 (char *) "text", NULL
27581 };
27582
27583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27584 if (obj0) {
27585 {
27586 arg1 = wxString_in_helper(obj0);
27587 if (arg1 == NULL) SWIG_fail;
27588 temp1 = true;
27589 }
27590 }
27591 {
27592 PyThreadState* __tstate = wxPyBeginAllowThreads();
27593 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27594
27595 wxPyEndAllowThreads(__tstate);
27596 if (PyErr_Occurred()) SWIG_fail;
27597 }
27598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27599 {
27600 if (temp1)
27601 delete arg1;
27602 }
27603 return resultobj;
27604 fail:
27605 {
27606 if (temp1)
27607 delete arg1;
27608 }
27609 return NULL;
27610 }
27611
27612
27613 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27614 PyObject *resultobj;
27615 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27616 PyObject *arg2 = (PyObject *) 0 ;
27617 PyObject *arg3 = (PyObject *) 0 ;
27618 PyObject * obj0 = 0 ;
27619 PyObject * obj1 = 0 ;
27620 PyObject * obj2 = 0 ;
27621 char *kwnames[] = {
27622 (char *) "self",(char *) "self",(char *) "_class", NULL
27623 };
27624
27625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27627 if (SWIG_arg_fail(1)) SWIG_fail;
27628 arg2 = obj1;
27629 arg3 = obj2;
27630 {
27631 PyThreadState* __tstate = wxPyBeginAllowThreads();
27632 (arg1)->_setCallbackInfo(arg2,arg3);
27633
27634 wxPyEndAllowThreads(__tstate);
27635 if (PyErr_Occurred()) SWIG_fail;
27636 }
27637 Py_INCREF(Py_None); resultobj = Py_None;
27638 return resultobj;
27639 fail:
27640 return NULL;
27641 }
27642
27643
27644 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27645 PyObject *obj;
27646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27647 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27648 Py_INCREF(obj);
27649 return Py_BuildValue((char *)"");
27650 }
27651 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27652 PyObject *resultobj;
27653 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27654 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27655 wxBitmapDataObject *result;
27656 PyObject * obj0 = 0 ;
27657 char *kwnames[] = {
27658 (char *) "bitmap", NULL
27659 };
27660
27661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27662 if (obj0) {
27663 {
27664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27665 if (SWIG_arg_fail(1)) SWIG_fail;
27666 if (arg1 == NULL) {
27667 SWIG_null_ref("wxBitmap");
27668 }
27669 if (SWIG_arg_fail(1)) SWIG_fail;
27670 }
27671 }
27672 {
27673 PyThreadState* __tstate = wxPyBeginAllowThreads();
27674 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27675
27676 wxPyEndAllowThreads(__tstate);
27677 if (PyErr_Occurred()) SWIG_fail;
27678 }
27679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27680 return resultobj;
27681 fail:
27682 return NULL;
27683 }
27684
27685
27686 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27687 PyObject *resultobj;
27688 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27689 wxBitmap result;
27690 PyObject * obj0 = 0 ;
27691 char *kwnames[] = {
27692 (char *) "self", NULL
27693 };
27694
27695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27697 if (SWIG_arg_fail(1)) SWIG_fail;
27698 {
27699 PyThreadState* __tstate = wxPyBeginAllowThreads();
27700 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27701
27702 wxPyEndAllowThreads(__tstate);
27703 if (PyErr_Occurred()) SWIG_fail;
27704 }
27705 {
27706 wxBitmap * resultptr;
27707 resultptr = new wxBitmap((wxBitmap &)(result));
27708 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27709 }
27710 return resultobj;
27711 fail:
27712 return NULL;
27713 }
27714
27715
27716 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27717 PyObject *resultobj;
27718 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27719 wxBitmap *arg2 = 0 ;
27720 PyObject * obj0 = 0 ;
27721 PyObject * obj1 = 0 ;
27722 char *kwnames[] = {
27723 (char *) "self",(char *) "bitmap", NULL
27724 };
27725
27726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27728 if (SWIG_arg_fail(1)) SWIG_fail;
27729 {
27730 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27731 if (SWIG_arg_fail(2)) SWIG_fail;
27732 if (arg2 == NULL) {
27733 SWIG_null_ref("wxBitmap");
27734 }
27735 if (SWIG_arg_fail(2)) SWIG_fail;
27736 }
27737 {
27738 PyThreadState* __tstate = wxPyBeginAllowThreads();
27739 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27740
27741 wxPyEndAllowThreads(__tstate);
27742 if (PyErr_Occurred()) SWIG_fail;
27743 }
27744 Py_INCREF(Py_None); resultobj = Py_None;
27745 return resultobj;
27746 fail:
27747 return NULL;
27748 }
27749
27750
27751 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27752 PyObject *obj;
27753 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27754 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27755 Py_INCREF(obj);
27756 return Py_BuildValue((char *)"");
27757 }
27758 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27759 PyObject *resultobj;
27760 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27761 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27762 wxPyBitmapDataObject *result;
27763 PyObject * obj0 = 0 ;
27764 char *kwnames[] = {
27765 (char *) "bitmap", NULL
27766 };
27767
27768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27769 if (obj0) {
27770 {
27771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27772 if (SWIG_arg_fail(1)) SWIG_fail;
27773 if (arg1 == NULL) {
27774 SWIG_null_ref("wxBitmap");
27775 }
27776 if (SWIG_arg_fail(1)) SWIG_fail;
27777 }
27778 }
27779 {
27780 PyThreadState* __tstate = wxPyBeginAllowThreads();
27781 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27782
27783 wxPyEndAllowThreads(__tstate);
27784 if (PyErr_Occurred()) SWIG_fail;
27785 }
27786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27787 return resultobj;
27788 fail:
27789 return NULL;
27790 }
27791
27792
27793 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27794 PyObject *resultobj;
27795 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27796 PyObject *arg2 = (PyObject *) 0 ;
27797 PyObject *arg3 = (PyObject *) 0 ;
27798 PyObject * obj0 = 0 ;
27799 PyObject * obj1 = 0 ;
27800 PyObject * obj2 = 0 ;
27801 char *kwnames[] = {
27802 (char *) "self",(char *) "self",(char *) "_class", NULL
27803 };
27804
27805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27807 if (SWIG_arg_fail(1)) SWIG_fail;
27808 arg2 = obj1;
27809 arg3 = obj2;
27810 {
27811 PyThreadState* __tstate = wxPyBeginAllowThreads();
27812 (arg1)->_setCallbackInfo(arg2,arg3);
27813
27814 wxPyEndAllowThreads(__tstate);
27815 if (PyErr_Occurred()) SWIG_fail;
27816 }
27817 Py_INCREF(Py_None); resultobj = Py_None;
27818 return resultobj;
27819 fail:
27820 return NULL;
27821 }
27822
27823
27824 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27825 PyObject *obj;
27826 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27827 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27828 Py_INCREF(obj);
27829 return Py_BuildValue((char *)"");
27830 }
27831 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27832 PyObject *resultobj;
27833 wxFileDataObject *result;
27834 char *kwnames[] = {
27835 NULL
27836 };
27837
27838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27839 {
27840 PyThreadState* __tstate = wxPyBeginAllowThreads();
27841 result = (wxFileDataObject *)new wxFileDataObject();
27842
27843 wxPyEndAllowThreads(__tstate);
27844 if (PyErr_Occurred()) SWIG_fail;
27845 }
27846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27847 return resultobj;
27848 fail:
27849 return NULL;
27850 }
27851
27852
27853 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27854 PyObject *resultobj;
27855 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27856 wxArrayString *result;
27857 PyObject * obj0 = 0 ;
27858 char *kwnames[] = {
27859 (char *) "self", NULL
27860 };
27861
27862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27864 if (SWIG_arg_fail(1)) SWIG_fail;
27865 {
27866 PyThreadState* __tstate = wxPyBeginAllowThreads();
27867 {
27868 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27869 result = (wxArrayString *) &_result_ref;
27870 }
27871
27872 wxPyEndAllowThreads(__tstate);
27873 if (PyErr_Occurred()) SWIG_fail;
27874 }
27875 {
27876 resultobj = wxArrayString2PyList_helper(*result);
27877 }
27878 return resultobj;
27879 fail:
27880 return NULL;
27881 }
27882
27883
27884 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27885 PyObject *resultobj;
27886 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27887 wxString *arg2 = 0 ;
27888 bool temp2 = false ;
27889 PyObject * obj0 = 0 ;
27890 PyObject * obj1 = 0 ;
27891 char *kwnames[] = {
27892 (char *) "self",(char *) "filename", NULL
27893 };
27894
27895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
27896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27897 if (SWIG_arg_fail(1)) SWIG_fail;
27898 {
27899 arg2 = wxString_in_helper(obj1);
27900 if (arg2 == NULL) SWIG_fail;
27901 temp2 = true;
27902 }
27903 {
27904 PyThreadState* __tstate = wxPyBeginAllowThreads();
27905 (arg1)->AddFile((wxString const &)*arg2);
27906
27907 wxPyEndAllowThreads(__tstate);
27908 if (PyErr_Occurred()) SWIG_fail;
27909 }
27910 Py_INCREF(Py_None); resultobj = Py_None;
27911 {
27912 if (temp2)
27913 delete arg2;
27914 }
27915 return resultobj;
27916 fail:
27917 {
27918 if (temp2)
27919 delete arg2;
27920 }
27921 return NULL;
27922 }
27923
27924
27925 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
27926 PyObject *obj;
27927 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27928 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
27929 Py_INCREF(obj);
27930 return Py_BuildValue((char *)"");
27931 }
27932 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
27933 PyObject *resultobj;
27934 wxDataFormat *arg1 = 0 ;
27935 wxCustomDataObject *result;
27936 PyObject * obj0 = 0 ;
27937
27938 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27939 {
27940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27941 if (SWIG_arg_fail(1)) SWIG_fail;
27942 if (arg1 == NULL) {
27943 SWIG_null_ref("wxDataFormat");
27944 }
27945 if (SWIG_arg_fail(1)) SWIG_fail;
27946 }
27947 {
27948 PyThreadState* __tstate = wxPyBeginAllowThreads();
27949 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
27950
27951 wxPyEndAllowThreads(__tstate);
27952 if (PyErr_Occurred()) SWIG_fail;
27953 }
27954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
27962 PyObject *resultobj;
27963 wxString *arg1 = 0 ;
27964 wxCustomDataObject *result;
27965 bool temp1 = false ;
27966 PyObject * obj0 = 0 ;
27967
27968 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27969 {
27970 arg1 = wxString_in_helper(obj0);
27971 if (arg1 == NULL) SWIG_fail;
27972 temp1 = true;
27973 }
27974 {
27975 PyThreadState* __tstate = wxPyBeginAllowThreads();
27976 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
27977
27978 wxPyEndAllowThreads(__tstate);
27979 if (PyErr_Occurred()) SWIG_fail;
27980 }
27981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27982 {
27983 if (temp1)
27984 delete arg1;
27985 }
27986 return resultobj;
27987 fail:
27988 {
27989 if (temp1)
27990 delete arg1;
27991 }
27992 return NULL;
27993 }
27994
27995
27996 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
27997 PyObject *resultobj;
27998 wxCustomDataObject *result;
27999
28000 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28001 {
28002 PyThreadState* __tstate = wxPyBeginAllowThreads();
28003 result = (wxCustomDataObject *)new wxCustomDataObject();
28004
28005 wxPyEndAllowThreads(__tstate);
28006 if (PyErr_Occurred()) SWIG_fail;
28007 }
28008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28009 return resultobj;
28010 fail:
28011 return NULL;
28012 }
28013
28014
28015 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28016 int argc;
28017 PyObject *argv[2];
28018 int ii;
28019
28020 argc = PyObject_Length(args);
28021 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28022 argv[ii] = PyTuple_GetItem(args,ii);
28023 }
28024 if (argc == 0) {
28025 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28026 }
28027 if (argc == 1) {
28028 int _v;
28029 {
28030 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28031 }
28032 if (_v) {
28033 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28034 }
28035 }
28036 if (argc == 1) {
28037 int _v;
28038 {
28039 void *ptr = 0;
28040 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28041 _v = 0;
28042 PyErr_Clear();
28043 } else {
28044 _v = (ptr != 0);
28045 }
28046 }
28047 if (_v) {
28048 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28049 }
28050 }
28051
28052 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28053 return NULL;
28054 }
28055
28056
28057 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28058 PyObject *resultobj;
28059 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28060 PyObject *arg2 = (PyObject *) 0 ;
28061 bool result;
28062 PyObject * obj0 = 0 ;
28063 PyObject * obj1 = 0 ;
28064 char *kwnames[] = {
28065 (char *) "self",(char *) "data", NULL
28066 };
28067
28068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28070 if (SWIG_arg_fail(1)) SWIG_fail;
28071 arg2 = obj1;
28072 {
28073 PyThreadState* __tstate = wxPyBeginAllowThreads();
28074 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28075
28076 wxPyEndAllowThreads(__tstate);
28077 if (PyErr_Occurred()) SWIG_fail;
28078 }
28079 {
28080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28081 }
28082 return resultobj;
28083 fail:
28084 return NULL;
28085 }
28086
28087
28088 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28089 PyObject *resultobj;
28090 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28091 size_t result;
28092 PyObject * obj0 = 0 ;
28093 char *kwnames[] = {
28094 (char *) "self", NULL
28095 };
28096
28097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28099 if (SWIG_arg_fail(1)) SWIG_fail;
28100 {
28101 PyThreadState* __tstate = wxPyBeginAllowThreads();
28102 result = (size_t)(arg1)->GetSize();
28103
28104 wxPyEndAllowThreads(__tstate);
28105 if (PyErr_Occurred()) SWIG_fail;
28106 }
28107 {
28108 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28109 }
28110 return resultobj;
28111 fail:
28112 return NULL;
28113 }
28114
28115
28116 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28117 PyObject *resultobj;
28118 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28119 PyObject *result;
28120 PyObject * obj0 = 0 ;
28121 char *kwnames[] = {
28122 (char *) "self", NULL
28123 };
28124
28125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28127 if (SWIG_arg_fail(1)) SWIG_fail;
28128 {
28129 PyThreadState* __tstate = wxPyBeginAllowThreads();
28130 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28131
28132 wxPyEndAllowThreads(__tstate);
28133 if (PyErr_Occurred()) SWIG_fail;
28134 }
28135 resultobj = result;
28136 return resultobj;
28137 fail:
28138 return NULL;
28139 }
28140
28141
28142 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28143 PyObject *obj;
28144 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28145 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28146 Py_INCREF(obj);
28147 return Py_BuildValue((char *)"");
28148 }
28149 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28150 PyObject *resultobj;
28151 wxURLDataObject *result;
28152 char *kwnames[] = {
28153 NULL
28154 };
28155
28156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28157 {
28158 PyThreadState* __tstate = wxPyBeginAllowThreads();
28159 result = (wxURLDataObject *)new wxURLDataObject();
28160
28161 wxPyEndAllowThreads(__tstate);
28162 if (PyErr_Occurred()) SWIG_fail;
28163 }
28164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28165 return resultobj;
28166 fail:
28167 return NULL;
28168 }
28169
28170
28171 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28172 PyObject *resultobj;
28173 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28174 wxString result;
28175 PyObject * obj0 = 0 ;
28176 char *kwnames[] = {
28177 (char *) "self", NULL
28178 };
28179
28180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28182 if (SWIG_arg_fail(1)) SWIG_fail;
28183 {
28184 PyThreadState* __tstate = wxPyBeginAllowThreads();
28185 result = (arg1)->GetURL();
28186
28187 wxPyEndAllowThreads(__tstate);
28188 if (PyErr_Occurred()) SWIG_fail;
28189 }
28190 {
28191 #if wxUSE_UNICODE
28192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28193 #else
28194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28195 #endif
28196 }
28197 return resultobj;
28198 fail:
28199 return NULL;
28200 }
28201
28202
28203 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28204 PyObject *resultobj;
28205 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28206 wxString *arg2 = 0 ;
28207 bool temp2 = false ;
28208 PyObject * obj0 = 0 ;
28209 PyObject * obj1 = 0 ;
28210 char *kwnames[] = {
28211 (char *) "self",(char *) "url", NULL
28212 };
28213
28214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28216 if (SWIG_arg_fail(1)) SWIG_fail;
28217 {
28218 arg2 = wxString_in_helper(obj1);
28219 if (arg2 == NULL) SWIG_fail;
28220 temp2 = true;
28221 }
28222 {
28223 PyThreadState* __tstate = wxPyBeginAllowThreads();
28224 (arg1)->SetURL((wxString const &)*arg2);
28225
28226 wxPyEndAllowThreads(__tstate);
28227 if (PyErr_Occurred()) SWIG_fail;
28228 }
28229 Py_INCREF(Py_None); resultobj = Py_None;
28230 {
28231 if (temp2)
28232 delete arg2;
28233 }
28234 return resultobj;
28235 fail:
28236 {
28237 if (temp2)
28238 delete arg2;
28239 }
28240 return NULL;
28241 }
28242
28243
28244 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28245 PyObject *obj;
28246 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28247 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28248 Py_INCREF(obj);
28249 return Py_BuildValue((char *)"");
28250 }
28251 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28252 PyObject *resultobj;
28253 wxMetafileDataObject *result;
28254 char *kwnames[] = {
28255 NULL
28256 };
28257
28258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28259 {
28260 PyThreadState* __tstate = wxPyBeginAllowThreads();
28261 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28262
28263 wxPyEndAllowThreads(__tstate);
28264 if (PyErr_Occurred()) SWIG_fail;
28265 }
28266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28267 return resultobj;
28268 fail:
28269 return NULL;
28270 }
28271
28272
28273 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28274 PyObject *obj;
28275 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28276 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28277 Py_INCREF(obj);
28278 return Py_BuildValue((char *)"");
28279 }
28280 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28281 PyObject *resultobj;
28282 wxDragResult arg1 ;
28283 bool result;
28284 PyObject * obj0 = 0 ;
28285 char *kwnames[] = {
28286 (char *) "res", NULL
28287 };
28288
28289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28290 {
28291 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28292 if (SWIG_arg_fail(1)) SWIG_fail;
28293 }
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28297
28298 wxPyEndAllowThreads(__tstate);
28299 if (PyErr_Occurred()) SWIG_fail;
28300 }
28301 {
28302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28303 }
28304 return resultobj;
28305 fail:
28306 return NULL;
28307 }
28308
28309
28310 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28311 PyObject *resultobj;
28312 wxWindow *arg1 = (wxWindow *) 0 ;
28313 wxIcon const &arg2_defvalue = wxNullIcon ;
28314 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28315 wxIcon const &arg3_defvalue = wxNullIcon ;
28316 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28317 wxIcon const &arg4_defvalue = wxNullIcon ;
28318 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28319 wxPyDropSource *result;
28320 PyObject * obj0 = 0 ;
28321 PyObject * obj1 = 0 ;
28322 PyObject * obj2 = 0 ;
28323 PyObject * obj3 = 0 ;
28324 char *kwnames[] = {
28325 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28326 };
28327
28328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28330 if (SWIG_arg_fail(1)) SWIG_fail;
28331 if (obj1) {
28332 {
28333 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28334 if (SWIG_arg_fail(2)) SWIG_fail;
28335 if (arg2 == NULL) {
28336 SWIG_null_ref("wxIcon");
28337 }
28338 if (SWIG_arg_fail(2)) SWIG_fail;
28339 }
28340 }
28341 if (obj2) {
28342 {
28343 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28344 if (SWIG_arg_fail(3)) SWIG_fail;
28345 if (arg3 == NULL) {
28346 SWIG_null_ref("wxIcon");
28347 }
28348 if (SWIG_arg_fail(3)) SWIG_fail;
28349 }
28350 }
28351 if (obj3) {
28352 {
28353 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28354 if (SWIG_arg_fail(4)) SWIG_fail;
28355 if (arg4 == NULL) {
28356 SWIG_null_ref("wxIcon");
28357 }
28358 if (SWIG_arg_fail(4)) SWIG_fail;
28359 }
28360 }
28361 {
28362 PyThreadState* __tstate = wxPyBeginAllowThreads();
28363 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28364
28365 wxPyEndAllowThreads(__tstate);
28366 if (PyErr_Occurred()) SWIG_fail;
28367 }
28368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28369 return resultobj;
28370 fail:
28371 return NULL;
28372 }
28373
28374
28375 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28376 PyObject *resultobj;
28377 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28378 PyObject *arg2 = (PyObject *) 0 ;
28379 PyObject *arg3 = (PyObject *) 0 ;
28380 int arg4 ;
28381 PyObject * obj0 = 0 ;
28382 PyObject * obj1 = 0 ;
28383 PyObject * obj2 = 0 ;
28384 PyObject * obj3 = 0 ;
28385 char *kwnames[] = {
28386 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28387 };
28388
28389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28391 if (SWIG_arg_fail(1)) SWIG_fail;
28392 arg2 = obj1;
28393 arg3 = obj2;
28394 {
28395 arg4 = (int)(SWIG_As_int(obj3));
28396 if (SWIG_arg_fail(4)) SWIG_fail;
28397 }
28398 {
28399 PyThreadState* __tstate = wxPyBeginAllowThreads();
28400 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28401
28402 wxPyEndAllowThreads(__tstate);
28403 if (PyErr_Occurred()) SWIG_fail;
28404 }
28405 Py_INCREF(Py_None); resultobj = Py_None;
28406 return resultobj;
28407 fail:
28408 return NULL;
28409 }
28410
28411
28412 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28413 PyObject *resultobj;
28414 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28415 PyObject * obj0 = 0 ;
28416 char *kwnames[] = {
28417 (char *) "self", NULL
28418 };
28419
28420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28422 if (SWIG_arg_fail(1)) SWIG_fail;
28423 {
28424 PyThreadState* __tstate = wxPyBeginAllowThreads();
28425 delete arg1;
28426
28427 wxPyEndAllowThreads(__tstate);
28428 if (PyErr_Occurred()) SWIG_fail;
28429 }
28430 Py_INCREF(Py_None); resultobj = Py_None;
28431 return resultobj;
28432 fail:
28433 return NULL;
28434 }
28435
28436
28437 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28438 PyObject *resultobj;
28439 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28440 wxDataObject *arg2 = 0 ;
28441 PyObject * obj0 = 0 ;
28442 PyObject * obj1 = 0 ;
28443 char *kwnames[] = {
28444 (char *) "self",(char *) "data", NULL
28445 };
28446
28447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28449 if (SWIG_arg_fail(1)) SWIG_fail;
28450 {
28451 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28452 if (SWIG_arg_fail(2)) SWIG_fail;
28453 if (arg2 == NULL) {
28454 SWIG_null_ref("wxDataObject");
28455 }
28456 if (SWIG_arg_fail(2)) SWIG_fail;
28457 }
28458 {
28459 PyThreadState* __tstate = wxPyBeginAllowThreads();
28460 (arg1)->SetData(*arg2);
28461
28462 wxPyEndAllowThreads(__tstate);
28463 if (PyErr_Occurred()) SWIG_fail;
28464 }
28465 Py_INCREF(Py_None); resultobj = Py_None;
28466 return resultobj;
28467 fail:
28468 return NULL;
28469 }
28470
28471
28472 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28473 PyObject *resultobj;
28474 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28475 wxDataObject *result;
28476 PyObject * obj0 = 0 ;
28477 char *kwnames[] = {
28478 (char *) "self", NULL
28479 };
28480
28481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28483 if (SWIG_arg_fail(1)) SWIG_fail;
28484 {
28485 PyThreadState* __tstate = wxPyBeginAllowThreads();
28486 result = (wxDataObject *)(arg1)->GetDataObject();
28487
28488 wxPyEndAllowThreads(__tstate);
28489 if (PyErr_Occurred()) SWIG_fail;
28490 }
28491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28492 return resultobj;
28493 fail:
28494 return NULL;
28495 }
28496
28497
28498 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28499 PyObject *resultobj;
28500 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28501 wxDragResult arg2 ;
28502 wxCursor *arg3 = 0 ;
28503 PyObject * obj0 = 0 ;
28504 PyObject * obj1 = 0 ;
28505 PyObject * obj2 = 0 ;
28506 char *kwnames[] = {
28507 (char *) "self",(char *) "res",(char *) "cursor", NULL
28508 };
28509
28510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28512 if (SWIG_arg_fail(1)) SWIG_fail;
28513 {
28514 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28515 if (SWIG_arg_fail(2)) SWIG_fail;
28516 }
28517 {
28518 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28519 if (SWIG_arg_fail(3)) SWIG_fail;
28520 if (arg3 == NULL) {
28521 SWIG_null_ref("wxCursor");
28522 }
28523 if (SWIG_arg_fail(3)) SWIG_fail;
28524 }
28525 {
28526 PyThreadState* __tstate = wxPyBeginAllowThreads();
28527 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28528
28529 wxPyEndAllowThreads(__tstate);
28530 if (PyErr_Occurred()) SWIG_fail;
28531 }
28532 Py_INCREF(Py_None); resultobj = Py_None;
28533 return resultobj;
28534 fail:
28535 return NULL;
28536 }
28537
28538
28539 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28540 PyObject *resultobj;
28541 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28542 int arg2 = (int) wxDrag_CopyOnly ;
28543 wxDragResult result;
28544 PyObject * obj0 = 0 ;
28545 PyObject * obj1 = 0 ;
28546 char *kwnames[] = {
28547 (char *) "self",(char *) "flags", NULL
28548 };
28549
28550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28552 if (SWIG_arg_fail(1)) SWIG_fail;
28553 if (obj1) {
28554 {
28555 arg2 = (int)(SWIG_As_int(obj1));
28556 if (SWIG_arg_fail(2)) SWIG_fail;
28557 }
28558 }
28559 {
28560 PyThreadState* __tstate = wxPyBeginAllowThreads();
28561 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28562
28563 wxPyEndAllowThreads(__tstate);
28564 if (PyErr_Occurred()) SWIG_fail;
28565 }
28566 resultobj = SWIG_From_int((result));
28567 return resultobj;
28568 fail:
28569 return NULL;
28570 }
28571
28572
28573 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28574 PyObject *resultobj;
28575 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28576 wxDragResult arg2 ;
28577 bool result;
28578 PyObject * obj0 = 0 ;
28579 PyObject * obj1 = 0 ;
28580 char *kwnames[] = {
28581 (char *) "self",(char *) "effect", NULL
28582 };
28583
28584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28586 if (SWIG_arg_fail(1)) SWIG_fail;
28587 {
28588 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28589 if (SWIG_arg_fail(2)) SWIG_fail;
28590 }
28591 {
28592 PyThreadState* __tstate = wxPyBeginAllowThreads();
28593 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28594
28595 wxPyEndAllowThreads(__tstate);
28596 if (PyErr_Occurred()) SWIG_fail;
28597 }
28598 {
28599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28600 }
28601 return resultobj;
28602 fail:
28603 return NULL;
28604 }
28605
28606
28607 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28608 PyObject *obj;
28609 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28610 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28611 Py_INCREF(obj);
28612 return Py_BuildValue((char *)"");
28613 }
28614 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28615 PyObject *resultobj;
28616 wxDataObject *arg1 = (wxDataObject *) NULL ;
28617 wxPyDropTarget *result;
28618 PyObject * obj0 = 0 ;
28619 char *kwnames[] = {
28620 (char *) "dataObject", NULL
28621 };
28622
28623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28624 if (obj0) {
28625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28626 if (SWIG_arg_fail(1)) SWIG_fail;
28627 }
28628 {
28629 PyThreadState* __tstate = wxPyBeginAllowThreads();
28630 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28631
28632 wxPyEndAllowThreads(__tstate);
28633 if (PyErr_Occurred()) SWIG_fail;
28634 }
28635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28636 return resultobj;
28637 fail:
28638 return NULL;
28639 }
28640
28641
28642 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28643 PyObject *resultobj;
28644 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28645 PyObject *arg2 = (PyObject *) 0 ;
28646 PyObject *arg3 = (PyObject *) 0 ;
28647 PyObject * obj0 = 0 ;
28648 PyObject * obj1 = 0 ;
28649 PyObject * obj2 = 0 ;
28650 char *kwnames[] = {
28651 (char *) "self",(char *) "self",(char *) "_class", NULL
28652 };
28653
28654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28656 if (SWIG_arg_fail(1)) SWIG_fail;
28657 arg2 = obj1;
28658 arg3 = obj2;
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 (arg1)->_setCallbackInfo(arg2,arg3);
28662
28663 wxPyEndAllowThreads(__tstate);
28664 if (PyErr_Occurred()) SWIG_fail;
28665 }
28666 Py_INCREF(Py_None); resultobj = Py_None;
28667 return resultobj;
28668 fail:
28669 return NULL;
28670 }
28671
28672
28673 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28674 PyObject *resultobj;
28675 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28676 PyObject * obj0 = 0 ;
28677 char *kwnames[] = {
28678 (char *) "self", NULL
28679 };
28680
28681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28683 if (SWIG_arg_fail(1)) SWIG_fail;
28684 {
28685 PyThreadState* __tstate = wxPyBeginAllowThreads();
28686 delete arg1;
28687
28688 wxPyEndAllowThreads(__tstate);
28689 if (PyErr_Occurred()) SWIG_fail;
28690 }
28691 Py_INCREF(Py_None); resultobj = Py_None;
28692 return resultobj;
28693 fail:
28694 return NULL;
28695 }
28696
28697
28698 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28699 PyObject *resultobj;
28700 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28701 wxDataObject *result;
28702 PyObject * obj0 = 0 ;
28703 char *kwnames[] = {
28704 (char *) "self", NULL
28705 };
28706
28707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28709 if (SWIG_arg_fail(1)) SWIG_fail;
28710 {
28711 PyThreadState* __tstate = wxPyBeginAllowThreads();
28712 result = (wxDataObject *)(arg1)->GetDataObject();
28713
28714 wxPyEndAllowThreads(__tstate);
28715 if (PyErr_Occurred()) SWIG_fail;
28716 }
28717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28718 return resultobj;
28719 fail:
28720 return NULL;
28721 }
28722
28723
28724 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28725 PyObject *resultobj;
28726 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28727 wxDataObject *arg2 = (wxDataObject *) 0 ;
28728 PyObject * obj0 = 0 ;
28729 PyObject * obj1 = 0 ;
28730 char *kwnames[] = {
28731 (char *) "self",(char *) "dataObject", NULL
28732 };
28733
28734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28736 if (SWIG_arg_fail(1)) SWIG_fail;
28737 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28738 if (SWIG_arg_fail(2)) SWIG_fail;
28739 {
28740 PyThreadState* __tstate = wxPyBeginAllowThreads();
28741 (arg1)->SetDataObject(arg2);
28742
28743 wxPyEndAllowThreads(__tstate);
28744 if (PyErr_Occurred()) SWIG_fail;
28745 }
28746 Py_INCREF(Py_None); resultobj = Py_None;
28747 return resultobj;
28748 fail:
28749 return NULL;
28750 }
28751
28752
28753 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28754 PyObject *resultobj;
28755 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28756 int arg2 ;
28757 int arg3 ;
28758 wxDragResult arg4 ;
28759 wxDragResult result;
28760 PyObject * obj0 = 0 ;
28761 PyObject * obj1 = 0 ;
28762 PyObject * obj2 = 0 ;
28763 PyObject * obj3 = 0 ;
28764 char *kwnames[] = {
28765 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28766 };
28767
28768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28770 if (SWIG_arg_fail(1)) SWIG_fail;
28771 {
28772 arg2 = (int)(SWIG_As_int(obj1));
28773 if (SWIG_arg_fail(2)) SWIG_fail;
28774 }
28775 {
28776 arg3 = (int)(SWIG_As_int(obj2));
28777 if (SWIG_arg_fail(3)) SWIG_fail;
28778 }
28779 {
28780 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28781 if (SWIG_arg_fail(4)) SWIG_fail;
28782 }
28783 {
28784 PyThreadState* __tstate = wxPyBeginAllowThreads();
28785 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28786
28787 wxPyEndAllowThreads(__tstate);
28788 if (PyErr_Occurred()) SWIG_fail;
28789 }
28790 resultobj = SWIG_From_int((result));
28791 return resultobj;
28792 fail:
28793 return NULL;
28794 }
28795
28796
28797 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28798 PyObject *resultobj;
28799 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28800 int arg2 ;
28801 int arg3 ;
28802 wxDragResult arg4 ;
28803 wxDragResult result;
28804 PyObject * obj0 = 0 ;
28805 PyObject * obj1 = 0 ;
28806 PyObject * obj2 = 0 ;
28807 PyObject * obj3 = 0 ;
28808 char *kwnames[] = {
28809 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28810 };
28811
28812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28814 if (SWIG_arg_fail(1)) SWIG_fail;
28815 {
28816 arg2 = (int)(SWIG_As_int(obj1));
28817 if (SWIG_arg_fail(2)) SWIG_fail;
28818 }
28819 {
28820 arg3 = (int)(SWIG_As_int(obj2));
28821 if (SWIG_arg_fail(3)) SWIG_fail;
28822 }
28823 {
28824 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28825 if (SWIG_arg_fail(4)) SWIG_fail;
28826 }
28827 {
28828 PyThreadState* __tstate = wxPyBeginAllowThreads();
28829 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28830
28831 wxPyEndAllowThreads(__tstate);
28832 if (PyErr_Occurred()) SWIG_fail;
28833 }
28834 resultobj = SWIG_From_int((result));
28835 return resultobj;
28836 fail:
28837 return NULL;
28838 }
28839
28840
28841 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28842 PyObject *resultobj;
28843 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28844 PyObject * obj0 = 0 ;
28845 char *kwnames[] = {
28846 (char *) "self", NULL
28847 };
28848
28849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28851 if (SWIG_arg_fail(1)) SWIG_fail;
28852 {
28853 PyThreadState* __tstate = wxPyBeginAllowThreads();
28854 (arg1)->base_OnLeave();
28855
28856 wxPyEndAllowThreads(__tstate);
28857 if (PyErr_Occurred()) SWIG_fail;
28858 }
28859 Py_INCREF(Py_None); resultobj = Py_None;
28860 return resultobj;
28861 fail:
28862 return NULL;
28863 }
28864
28865
28866 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28867 PyObject *resultobj;
28868 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28869 int arg2 ;
28870 int arg3 ;
28871 bool result;
28872 PyObject * obj0 = 0 ;
28873 PyObject * obj1 = 0 ;
28874 PyObject * obj2 = 0 ;
28875 char *kwnames[] = {
28876 (char *) "self",(char *) "x",(char *) "y", NULL
28877 };
28878
28879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28881 if (SWIG_arg_fail(1)) SWIG_fail;
28882 {
28883 arg2 = (int)(SWIG_As_int(obj1));
28884 if (SWIG_arg_fail(2)) SWIG_fail;
28885 }
28886 {
28887 arg3 = (int)(SWIG_As_int(obj2));
28888 if (SWIG_arg_fail(3)) SWIG_fail;
28889 }
28890 {
28891 PyThreadState* __tstate = wxPyBeginAllowThreads();
28892 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28893
28894 wxPyEndAllowThreads(__tstate);
28895 if (PyErr_Occurred()) SWIG_fail;
28896 }
28897 {
28898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28899 }
28900 return resultobj;
28901 fail:
28902 return NULL;
28903 }
28904
28905
28906 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28907 PyObject *resultobj;
28908 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28909 bool result;
28910 PyObject * obj0 = 0 ;
28911 char *kwnames[] = {
28912 (char *) "self", NULL
28913 };
28914
28915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
28916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28917 if (SWIG_arg_fail(1)) SWIG_fail;
28918 {
28919 PyThreadState* __tstate = wxPyBeginAllowThreads();
28920 result = (bool)(arg1)->GetData();
28921
28922 wxPyEndAllowThreads(__tstate);
28923 if (PyErr_Occurred()) SWIG_fail;
28924 }
28925 {
28926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28927 }
28928 return resultobj;
28929 fail:
28930 return NULL;
28931 }
28932
28933
28934 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
28935 PyObject *obj;
28936 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28937 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
28938 Py_INCREF(obj);
28939 return Py_BuildValue((char *)"");
28940 }
28941 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28942 PyObject *resultobj;
28943 wxPyTextDropTarget *result;
28944 char *kwnames[] = {
28945 NULL
28946 };
28947
28948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
28949 {
28950 PyThreadState* __tstate = wxPyBeginAllowThreads();
28951 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
28952
28953 wxPyEndAllowThreads(__tstate);
28954 if (PyErr_Occurred()) SWIG_fail;
28955 }
28956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
28957 return resultobj;
28958 fail:
28959 return NULL;
28960 }
28961
28962
28963 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28964 PyObject *resultobj;
28965 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28966 PyObject *arg2 = (PyObject *) 0 ;
28967 PyObject *arg3 = (PyObject *) 0 ;
28968 PyObject * obj0 = 0 ;
28969 PyObject * obj1 = 0 ;
28970 PyObject * obj2 = 0 ;
28971 char *kwnames[] = {
28972 (char *) "self",(char *) "self",(char *) "_class", NULL
28973 };
28974
28975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28977 if (SWIG_arg_fail(1)) SWIG_fail;
28978 arg2 = obj1;
28979 arg3 = obj2;
28980 {
28981 PyThreadState* __tstate = wxPyBeginAllowThreads();
28982 (arg1)->_setCallbackInfo(arg2,arg3);
28983
28984 wxPyEndAllowThreads(__tstate);
28985 if (PyErr_Occurred()) SWIG_fail;
28986 }
28987 Py_INCREF(Py_None); resultobj = Py_None;
28988 return resultobj;
28989 fail:
28990 return NULL;
28991 }
28992
28993
28994 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28995 PyObject *resultobj;
28996 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28997 int arg2 ;
28998 int arg3 ;
28999 wxDragResult arg4 ;
29000 wxDragResult result;
29001 PyObject * obj0 = 0 ;
29002 PyObject * obj1 = 0 ;
29003 PyObject * obj2 = 0 ;
29004 PyObject * obj3 = 0 ;
29005 char *kwnames[] = {
29006 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29007 };
29008
29009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29011 if (SWIG_arg_fail(1)) SWIG_fail;
29012 {
29013 arg2 = (int)(SWIG_As_int(obj1));
29014 if (SWIG_arg_fail(2)) SWIG_fail;
29015 }
29016 {
29017 arg3 = (int)(SWIG_As_int(obj2));
29018 if (SWIG_arg_fail(3)) SWIG_fail;
29019 }
29020 {
29021 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29022 if (SWIG_arg_fail(4)) SWIG_fail;
29023 }
29024 {
29025 PyThreadState* __tstate = wxPyBeginAllowThreads();
29026 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29027
29028 wxPyEndAllowThreads(__tstate);
29029 if (PyErr_Occurred()) SWIG_fail;
29030 }
29031 resultobj = SWIG_From_int((result));
29032 return resultobj;
29033 fail:
29034 return NULL;
29035 }
29036
29037
29038 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29039 PyObject *resultobj;
29040 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29041 int arg2 ;
29042 int arg3 ;
29043 wxDragResult arg4 ;
29044 wxDragResult result;
29045 PyObject * obj0 = 0 ;
29046 PyObject * obj1 = 0 ;
29047 PyObject * obj2 = 0 ;
29048 PyObject * obj3 = 0 ;
29049 char *kwnames[] = {
29050 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29051 };
29052
29053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29055 if (SWIG_arg_fail(1)) SWIG_fail;
29056 {
29057 arg2 = (int)(SWIG_As_int(obj1));
29058 if (SWIG_arg_fail(2)) SWIG_fail;
29059 }
29060 {
29061 arg3 = (int)(SWIG_As_int(obj2));
29062 if (SWIG_arg_fail(3)) SWIG_fail;
29063 }
29064 {
29065 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29066 if (SWIG_arg_fail(4)) SWIG_fail;
29067 }
29068 {
29069 PyThreadState* __tstate = wxPyBeginAllowThreads();
29070 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29071
29072 wxPyEndAllowThreads(__tstate);
29073 if (PyErr_Occurred()) SWIG_fail;
29074 }
29075 resultobj = SWIG_From_int((result));
29076 return resultobj;
29077 fail:
29078 return NULL;
29079 }
29080
29081
29082 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29083 PyObject *resultobj;
29084 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29085 PyObject * obj0 = 0 ;
29086 char *kwnames[] = {
29087 (char *) "self", NULL
29088 };
29089
29090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29092 if (SWIG_arg_fail(1)) SWIG_fail;
29093 {
29094 PyThreadState* __tstate = wxPyBeginAllowThreads();
29095 (arg1)->base_OnLeave();
29096
29097 wxPyEndAllowThreads(__tstate);
29098 if (PyErr_Occurred()) SWIG_fail;
29099 }
29100 Py_INCREF(Py_None); resultobj = Py_None;
29101 return resultobj;
29102 fail:
29103 return NULL;
29104 }
29105
29106
29107 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29108 PyObject *resultobj;
29109 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29110 int arg2 ;
29111 int arg3 ;
29112 bool result;
29113 PyObject * obj0 = 0 ;
29114 PyObject * obj1 = 0 ;
29115 PyObject * obj2 = 0 ;
29116 char *kwnames[] = {
29117 (char *) "self",(char *) "x",(char *) "y", NULL
29118 };
29119
29120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29122 if (SWIG_arg_fail(1)) SWIG_fail;
29123 {
29124 arg2 = (int)(SWIG_As_int(obj1));
29125 if (SWIG_arg_fail(2)) SWIG_fail;
29126 }
29127 {
29128 arg3 = (int)(SWIG_As_int(obj2));
29129 if (SWIG_arg_fail(3)) SWIG_fail;
29130 }
29131 {
29132 PyThreadState* __tstate = wxPyBeginAllowThreads();
29133 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29134
29135 wxPyEndAllowThreads(__tstate);
29136 if (PyErr_Occurred()) SWIG_fail;
29137 }
29138 {
29139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29140 }
29141 return resultobj;
29142 fail:
29143 return NULL;
29144 }
29145
29146
29147 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29148 PyObject *resultobj;
29149 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29150 int arg2 ;
29151 int arg3 ;
29152 wxDragResult arg4 ;
29153 wxDragResult result;
29154 PyObject * obj0 = 0 ;
29155 PyObject * obj1 = 0 ;
29156 PyObject * obj2 = 0 ;
29157 PyObject * obj3 = 0 ;
29158 char *kwnames[] = {
29159 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29160 };
29161
29162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29164 if (SWIG_arg_fail(1)) SWIG_fail;
29165 {
29166 arg2 = (int)(SWIG_As_int(obj1));
29167 if (SWIG_arg_fail(2)) SWIG_fail;
29168 }
29169 {
29170 arg3 = (int)(SWIG_As_int(obj2));
29171 if (SWIG_arg_fail(3)) SWIG_fail;
29172 }
29173 {
29174 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29175 if (SWIG_arg_fail(4)) SWIG_fail;
29176 }
29177 {
29178 PyThreadState* __tstate = wxPyBeginAllowThreads();
29179 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29180
29181 wxPyEndAllowThreads(__tstate);
29182 if (PyErr_Occurred()) SWIG_fail;
29183 }
29184 resultobj = SWIG_From_int((result));
29185 return resultobj;
29186 fail:
29187 return NULL;
29188 }
29189
29190
29191 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29192 PyObject *obj;
29193 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29194 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29195 Py_INCREF(obj);
29196 return Py_BuildValue((char *)"");
29197 }
29198 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29199 PyObject *resultobj;
29200 wxPyFileDropTarget *result;
29201 char *kwnames[] = {
29202 NULL
29203 };
29204
29205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29206 {
29207 PyThreadState* __tstate = wxPyBeginAllowThreads();
29208 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29209
29210 wxPyEndAllowThreads(__tstate);
29211 if (PyErr_Occurred()) SWIG_fail;
29212 }
29213 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29214 return resultobj;
29215 fail:
29216 return NULL;
29217 }
29218
29219
29220 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29221 PyObject *resultobj;
29222 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29223 PyObject *arg2 = (PyObject *) 0 ;
29224 PyObject *arg3 = (PyObject *) 0 ;
29225 PyObject * obj0 = 0 ;
29226 PyObject * obj1 = 0 ;
29227 PyObject * obj2 = 0 ;
29228 char *kwnames[] = {
29229 (char *) "self",(char *) "self",(char *) "_class", NULL
29230 };
29231
29232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29234 if (SWIG_arg_fail(1)) SWIG_fail;
29235 arg2 = obj1;
29236 arg3 = obj2;
29237 {
29238 PyThreadState* __tstate = wxPyBeginAllowThreads();
29239 (arg1)->_setCallbackInfo(arg2,arg3);
29240
29241 wxPyEndAllowThreads(__tstate);
29242 if (PyErr_Occurred()) SWIG_fail;
29243 }
29244 Py_INCREF(Py_None); resultobj = Py_None;
29245 return resultobj;
29246 fail:
29247 return NULL;
29248 }
29249
29250
29251 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29252 PyObject *resultobj;
29253 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29254 int arg2 ;
29255 int arg3 ;
29256 wxDragResult arg4 ;
29257 wxDragResult result;
29258 PyObject * obj0 = 0 ;
29259 PyObject * obj1 = 0 ;
29260 PyObject * obj2 = 0 ;
29261 PyObject * obj3 = 0 ;
29262 char *kwnames[] = {
29263 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29264 };
29265
29266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29268 if (SWIG_arg_fail(1)) SWIG_fail;
29269 {
29270 arg2 = (int)(SWIG_As_int(obj1));
29271 if (SWIG_arg_fail(2)) SWIG_fail;
29272 }
29273 {
29274 arg3 = (int)(SWIG_As_int(obj2));
29275 if (SWIG_arg_fail(3)) SWIG_fail;
29276 }
29277 {
29278 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29279 if (SWIG_arg_fail(4)) SWIG_fail;
29280 }
29281 {
29282 PyThreadState* __tstate = wxPyBeginAllowThreads();
29283 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29284
29285 wxPyEndAllowThreads(__tstate);
29286 if (PyErr_Occurred()) SWIG_fail;
29287 }
29288 resultobj = SWIG_From_int((result));
29289 return resultobj;
29290 fail:
29291 return NULL;
29292 }
29293
29294
29295 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29296 PyObject *resultobj;
29297 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29298 int arg2 ;
29299 int arg3 ;
29300 wxDragResult arg4 ;
29301 wxDragResult result;
29302 PyObject * obj0 = 0 ;
29303 PyObject * obj1 = 0 ;
29304 PyObject * obj2 = 0 ;
29305 PyObject * obj3 = 0 ;
29306 char *kwnames[] = {
29307 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29308 };
29309
29310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29312 if (SWIG_arg_fail(1)) SWIG_fail;
29313 {
29314 arg2 = (int)(SWIG_As_int(obj1));
29315 if (SWIG_arg_fail(2)) SWIG_fail;
29316 }
29317 {
29318 arg3 = (int)(SWIG_As_int(obj2));
29319 if (SWIG_arg_fail(3)) SWIG_fail;
29320 }
29321 {
29322 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29323 if (SWIG_arg_fail(4)) SWIG_fail;
29324 }
29325 {
29326 PyThreadState* __tstate = wxPyBeginAllowThreads();
29327 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29328
29329 wxPyEndAllowThreads(__tstate);
29330 if (PyErr_Occurred()) SWIG_fail;
29331 }
29332 resultobj = SWIG_From_int((result));
29333 return resultobj;
29334 fail:
29335 return NULL;
29336 }
29337
29338
29339 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29340 PyObject *resultobj;
29341 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29342 PyObject * obj0 = 0 ;
29343 char *kwnames[] = {
29344 (char *) "self", NULL
29345 };
29346
29347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29349 if (SWIG_arg_fail(1)) SWIG_fail;
29350 {
29351 PyThreadState* __tstate = wxPyBeginAllowThreads();
29352 (arg1)->base_OnLeave();
29353
29354 wxPyEndAllowThreads(__tstate);
29355 if (PyErr_Occurred()) SWIG_fail;
29356 }
29357 Py_INCREF(Py_None); resultobj = Py_None;
29358 return resultobj;
29359 fail:
29360 return NULL;
29361 }
29362
29363
29364 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29365 PyObject *resultobj;
29366 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29367 int arg2 ;
29368 int arg3 ;
29369 bool result;
29370 PyObject * obj0 = 0 ;
29371 PyObject * obj1 = 0 ;
29372 PyObject * obj2 = 0 ;
29373 char *kwnames[] = {
29374 (char *) "self",(char *) "x",(char *) "y", NULL
29375 };
29376
29377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29379 if (SWIG_arg_fail(1)) SWIG_fail;
29380 {
29381 arg2 = (int)(SWIG_As_int(obj1));
29382 if (SWIG_arg_fail(2)) SWIG_fail;
29383 }
29384 {
29385 arg3 = (int)(SWIG_As_int(obj2));
29386 if (SWIG_arg_fail(3)) SWIG_fail;
29387 }
29388 {
29389 PyThreadState* __tstate = wxPyBeginAllowThreads();
29390 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29391
29392 wxPyEndAllowThreads(__tstate);
29393 if (PyErr_Occurred()) SWIG_fail;
29394 }
29395 {
29396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29397 }
29398 return resultobj;
29399 fail:
29400 return NULL;
29401 }
29402
29403
29404 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29405 PyObject *resultobj;
29406 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29407 int arg2 ;
29408 int arg3 ;
29409 wxDragResult arg4 ;
29410 wxDragResult result;
29411 PyObject * obj0 = 0 ;
29412 PyObject * obj1 = 0 ;
29413 PyObject * obj2 = 0 ;
29414 PyObject * obj3 = 0 ;
29415 char *kwnames[] = {
29416 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29417 };
29418
29419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29421 if (SWIG_arg_fail(1)) SWIG_fail;
29422 {
29423 arg2 = (int)(SWIG_As_int(obj1));
29424 if (SWIG_arg_fail(2)) SWIG_fail;
29425 }
29426 {
29427 arg3 = (int)(SWIG_As_int(obj2));
29428 if (SWIG_arg_fail(3)) SWIG_fail;
29429 }
29430 {
29431 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29432 if (SWIG_arg_fail(4)) SWIG_fail;
29433 }
29434 {
29435 PyThreadState* __tstate = wxPyBeginAllowThreads();
29436 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29437
29438 wxPyEndAllowThreads(__tstate);
29439 if (PyErr_Occurred()) SWIG_fail;
29440 }
29441 resultobj = SWIG_From_int((result));
29442 return resultobj;
29443 fail:
29444 return NULL;
29445 }
29446
29447
29448 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29449 PyObject *obj;
29450 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29451 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29452 Py_INCREF(obj);
29453 return Py_BuildValue((char *)"");
29454 }
29455 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29456 PyObject *resultobj;
29457 wxClipboard *result;
29458 char *kwnames[] = {
29459 NULL
29460 };
29461
29462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29463 {
29464 PyThreadState* __tstate = wxPyBeginAllowThreads();
29465 result = (wxClipboard *)new wxClipboard();
29466
29467 wxPyEndAllowThreads(__tstate);
29468 if (PyErr_Occurred()) SWIG_fail;
29469 }
29470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29471 return resultobj;
29472 fail:
29473 return NULL;
29474 }
29475
29476
29477 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29478 PyObject *resultobj;
29479 wxClipboard *arg1 = (wxClipboard *) 0 ;
29480 PyObject * obj0 = 0 ;
29481 char *kwnames[] = {
29482 (char *) "self", NULL
29483 };
29484
29485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29487 if (SWIG_arg_fail(1)) SWIG_fail;
29488 {
29489 PyThreadState* __tstate = wxPyBeginAllowThreads();
29490 delete arg1;
29491
29492 wxPyEndAllowThreads(__tstate);
29493 if (PyErr_Occurred()) SWIG_fail;
29494 }
29495 Py_INCREF(Py_None); resultobj = Py_None;
29496 return resultobj;
29497 fail:
29498 return NULL;
29499 }
29500
29501
29502 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29503 PyObject *resultobj;
29504 wxClipboard *arg1 = (wxClipboard *) 0 ;
29505 bool result;
29506 PyObject * obj0 = 0 ;
29507 char *kwnames[] = {
29508 (char *) "self", NULL
29509 };
29510
29511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29513 if (SWIG_arg_fail(1)) SWIG_fail;
29514 {
29515 PyThreadState* __tstate = wxPyBeginAllowThreads();
29516 result = (bool)(arg1)->Open();
29517
29518 wxPyEndAllowThreads(__tstate);
29519 if (PyErr_Occurred()) SWIG_fail;
29520 }
29521 {
29522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29523 }
29524 return resultobj;
29525 fail:
29526 return NULL;
29527 }
29528
29529
29530 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29531 PyObject *resultobj;
29532 wxClipboard *arg1 = (wxClipboard *) 0 ;
29533 PyObject * obj0 = 0 ;
29534 char *kwnames[] = {
29535 (char *) "self", NULL
29536 };
29537
29538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29540 if (SWIG_arg_fail(1)) SWIG_fail;
29541 {
29542 PyThreadState* __tstate = wxPyBeginAllowThreads();
29543 (arg1)->Close();
29544
29545 wxPyEndAllowThreads(__tstate);
29546 if (PyErr_Occurred()) SWIG_fail;
29547 }
29548 Py_INCREF(Py_None); resultobj = Py_None;
29549 return resultobj;
29550 fail:
29551 return NULL;
29552 }
29553
29554
29555 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29556 PyObject *resultobj;
29557 wxClipboard *arg1 = (wxClipboard *) 0 ;
29558 bool result;
29559 PyObject * obj0 = 0 ;
29560 char *kwnames[] = {
29561 (char *) "self", NULL
29562 };
29563
29564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29566 if (SWIG_arg_fail(1)) SWIG_fail;
29567 {
29568 PyThreadState* __tstate = wxPyBeginAllowThreads();
29569 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29570
29571 wxPyEndAllowThreads(__tstate);
29572 if (PyErr_Occurred()) SWIG_fail;
29573 }
29574 {
29575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29576 }
29577 return resultobj;
29578 fail:
29579 return NULL;
29580 }
29581
29582
29583 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29584 PyObject *resultobj;
29585 wxClipboard *arg1 = (wxClipboard *) 0 ;
29586 wxDataObject *arg2 = (wxDataObject *) 0 ;
29587 bool result;
29588 PyObject * obj0 = 0 ;
29589 PyObject * obj1 = 0 ;
29590 char *kwnames[] = {
29591 (char *) "self",(char *) "data", NULL
29592 };
29593
29594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29596 if (SWIG_arg_fail(1)) SWIG_fail;
29597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29598 if (SWIG_arg_fail(2)) SWIG_fail;
29599 {
29600 PyThreadState* __tstate = wxPyBeginAllowThreads();
29601 result = (bool)(arg1)->AddData(arg2);
29602
29603 wxPyEndAllowThreads(__tstate);
29604 if (PyErr_Occurred()) SWIG_fail;
29605 }
29606 {
29607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29608 }
29609 return resultobj;
29610 fail:
29611 return NULL;
29612 }
29613
29614
29615 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29616 PyObject *resultobj;
29617 wxClipboard *arg1 = (wxClipboard *) 0 ;
29618 wxDataObject *arg2 = (wxDataObject *) 0 ;
29619 bool result;
29620 PyObject * obj0 = 0 ;
29621 PyObject * obj1 = 0 ;
29622 char *kwnames[] = {
29623 (char *) "self",(char *) "data", NULL
29624 };
29625
29626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29628 if (SWIG_arg_fail(1)) SWIG_fail;
29629 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29630 if (SWIG_arg_fail(2)) SWIG_fail;
29631 {
29632 PyThreadState* __tstate = wxPyBeginAllowThreads();
29633 result = (bool)(arg1)->SetData(arg2);
29634
29635 wxPyEndAllowThreads(__tstate);
29636 if (PyErr_Occurred()) SWIG_fail;
29637 }
29638 {
29639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29640 }
29641 return resultobj;
29642 fail:
29643 return NULL;
29644 }
29645
29646
29647 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29648 PyObject *resultobj;
29649 wxClipboard *arg1 = (wxClipboard *) 0 ;
29650 wxDataFormat *arg2 = 0 ;
29651 bool result;
29652 PyObject * obj0 = 0 ;
29653 PyObject * obj1 = 0 ;
29654 char *kwnames[] = {
29655 (char *) "self",(char *) "format", NULL
29656 };
29657
29658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29660 if (SWIG_arg_fail(1)) SWIG_fail;
29661 {
29662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29663 if (SWIG_arg_fail(2)) SWIG_fail;
29664 if (arg2 == NULL) {
29665 SWIG_null_ref("wxDataFormat");
29666 }
29667 if (SWIG_arg_fail(2)) SWIG_fail;
29668 }
29669 {
29670 PyThreadState* __tstate = wxPyBeginAllowThreads();
29671 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29672
29673 wxPyEndAllowThreads(__tstate);
29674 if (PyErr_Occurred()) SWIG_fail;
29675 }
29676 {
29677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29678 }
29679 return resultobj;
29680 fail:
29681 return NULL;
29682 }
29683
29684
29685 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29686 PyObject *resultobj;
29687 wxClipboard *arg1 = (wxClipboard *) 0 ;
29688 wxDataObject *arg2 = 0 ;
29689 bool result;
29690 PyObject * obj0 = 0 ;
29691 PyObject * obj1 = 0 ;
29692 char *kwnames[] = {
29693 (char *) "self",(char *) "data", NULL
29694 };
29695
29696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29698 if (SWIG_arg_fail(1)) SWIG_fail;
29699 {
29700 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29701 if (SWIG_arg_fail(2)) SWIG_fail;
29702 if (arg2 == NULL) {
29703 SWIG_null_ref("wxDataObject");
29704 }
29705 if (SWIG_arg_fail(2)) SWIG_fail;
29706 }
29707 {
29708 PyThreadState* __tstate = wxPyBeginAllowThreads();
29709 result = (bool)(arg1)->GetData(*arg2);
29710
29711 wxPyEndAllowThreads(__tstate);
29712 if (PyErr_Occurred()) SWIG_fail;
29713 }
29714 {
29715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29716 }
29717 return resultobj;
29718 fail:
29719 return NULL;
29720 }
29721
29722
29723 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29724 PyObject *resultobj;
29725 wxClipboard *arg1 = (wxClipboard *) 0 ;
29726 PyObject * obj0 = 0 ;
29727 char *kwnames[] = {
29728 (char *) "self", NULL
29729 };
29730
29731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29733 if (SWIG_arg_fail(1)) SWIG_fail;
29734 {
29735 PyThreadState* __tstate = wxPyBeginAllowThreads();
29736 (arg1)->Clear();
29737
29738 wxPyEndAllowThreads(__tstate);
29739 if (PyErr_Occurred()) SWIG_fail;
29740 }
29741 Py_INCREF(Py_None); resultobj = Py_None;
29742 return resultobj;
29743 fail:
29744 return NULL;
29745 }
29746
29747
29748 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29749 PyObject *resultobj;
29750 wxClipboard *arg1 = (wxClipboard *) 0 ;
29751 bool result;
29752 PyObject * obj0 = 0 ;
29753 char *kwnames[] = {
29754 (char *) "self", NULL
29755 };
29756
29757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29759 if (SWIG_arg_fail(1)) SWIG_fail;
29760 {
29761 PyThreadState* __tstate = wxPyBeginAllowThreads();
29762 result = (bool)(arg1)->Flush();
29763
29764 wxPyEndAllowThreads(__tstate);
29765 if (PyErr_Occurred()) SWIG_fail;
29766 }
29767 {
29768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29769 }
29770 return resultobj;
29771 fail:
29772 return NULL;
29773 }
29774
29775
29776 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29777 PyObject *resultobj;
29778 wxClipboard *arg1 = (wxClipboard *) 0 ;
29779 bool arg2 = (bool) true ;
29780 PyObject * obj0 = 0 ;
29781 PyObject * obj1 = 0 ;
29782 char *kwnames[] = {
29783 (char *) "self",(char *) "primary", NULL
29784 };
29785
29786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29788 if (SWIG_arg_fail(1)) SWIG_fail;
29789 if (obj1) {
29790 {
29791 arg2 = (bool)(SWIG_As_bool(obj1));
29792 if (SWIG_arg_fail(2)) SWIG_fail;
29793 }
29794 }
29795 {
29796 PyThreadState* __tstate = wxPyBeginAllowThreads();
29797 (arg1)->UsePrimarySelection(arg2);
29798
29799 wxPyEndAllowThreads(__tstate);
29800 if (PyErr_Occurred()) SWIG_fail;
29801 }
29802 Py_INCREF(Py_None); resultobj = Py_None;
29803 return resultobj;
29804 fail:
29805 return NULL;
29806 }
29807
29808
29809 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29810 PyObject *resultobj;
29811 wxClipboard *result;
29812 char *kwnames[] = {
29813 NULL
29814 };
29815
29816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29817 {
29818 PyThreadState* __tstate = wxPyBeginAllowThreads();
29819 result = (wxClipboard *)wxClipboard::Get();
29820
29821 wxPyEndAllowThreads(__tstate);
29822 if (PyErr_Occurred()) SWIG_fail;
29823 }
29824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29825 return resultobj;
29826 fail:
29827 return NULL;
29828 }
29829
29830
29831 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29832 PyObject *obj;
29833 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29834 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29835 Py_INCREF(obj);
29836 return Py_BuildValue((char *)"");
29837 }
29838 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29839 PyObject *resultobj;
29840 wxClipboard *arg1 = (wxClipboard *) NULL ;
29841 wxClipboardLocker *result;
29842 PyObject * obj0 = 0 ;
29843 char *kwnames[] = {
29844 (char *) "clipboard", NULL
29845 };
29846
29847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29848 if (obj0) {
29849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29850 if (SWIG_arg_fail(1)) SWIG_fail;
29851 }
29852 {
29853 PyThreadState* __tstate = wxPyBeginAllowThreads();
29854 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29855
29856 wxPyEndAllowThreads(__tstate);
29857 if (PyErr_Occurred()) SWIG_fail;
29858 }
29859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29860 return resultobj;
29861 fail:
29862 return NULL;
29863 }
29864
29865
29866 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29867 PyObject *resultobj;
29868 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29869 PyObject * obj0 = 0 ;
29870 char *kwnames[] = {
29871 (char *) "self", NULL
29872 };
29873
29874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29876 if (SWIG_arg_fail(1)) SWIG_fail;
29877 {
29878 PyThreadState* __tstate = wxPyBeginAllowThreads();
29879 delete arg1;
29880
29881 wxPyEndAllowThreads(__tstate);
29882 if (PyErr_Occurred()) SWIG_fail;
29883 }
29884 Py_INCREF(Py_None); resultobj = Py_None;
29885 return resultobj;
29886 fail:
29887 return NULL;
29888 }
29889
29890
29891 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
29892 PyObject *resultobj;
29893 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29894 bool result;
29895 PyObject * obj0 = 0 ;
29896 char *kwnames[] = {
29897 (char *) "self", NULL
29898 };
29899
29900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
29901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29902 if (SWIG_arg_fail(1)) SWIG_fail;
29903 {
29904 PyThreadState* __tstate = wxPyBeginAllowThreads();
29905 result = (bool)wxClipboardLocker___nonzero__(arg1);
29906
29907 wxPyEndAllowThreads(__tstate);
29908 if (PyErr_Occurred()) SWIG_fail;
29909 }
29910 {
29911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29912 }
29913 return resultobj;
29914 fail:
29915 return NULL;
29916 }
29917
29918
29919 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
29920 PyObject *obj;
29921 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29922 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
29923 Py_INCREF(obj);
29924 return Py_BuildValue((char *)"");
29925 }
29926 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29927 PyObject *resultobj;
29928 int arg1 = (int) 0 ;
29929 int arg2 = (int) 0 ;
29930 int arg3 = (int) 0 ;
29931 int arg4 = (int) 0 ;
29932 wxVideoMode *result;
29933 PyObject * obj0 = 0 ;
29934 PyObject * obj1 = 0 ;
29935 PyObject * obj2 = 0 ;
29936 PyObject * obj3 = 0 ;
29937 char *kwnames[] = {
29938 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
29939 };
29940
29941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29942 if (obj0) {
29943 {
29944 arg1 = (int)(SWIG_As_int(obj0));
29945 if (SWIG_arg_fail(1)) SWIG_fail;
29946 }
29947 }
29948 if (obj1) {
29949 {
29950 arg2 = (int)(SWIG_As_int(obj1));
29951 if (SWIG_arg_fail(2)) SWIG_fail;
29952 }
29953 }
29954 if (obj2) {
29955 {
29956 arg3 = (int)(SWIG_As_int(obj2));
29957 if (SWIG_arg_fail(3)) SWIG_fail;
29958 }
29959 }
29960 if (obj3) {
29961 {
29962 arg4 = (int)(SWIG_As_int(obj3));
29963 if (SWIG_arg_fail(4)) SWIG_fail;
29964 }
29965 }
29966 {
29967 PyThreadState* __tstate = wxPyBeginAllowThreads();
29968 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
29969
29970 wxPyEndAllowThreads(__tstate);
29971 if (PyErr_Occurred()) SWIG_fail;
29972 }
29973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
29974 return resultobj;
29975 fail:
29976 return NULL;
29977 }
29978
29979
29980 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29981 PyObject *resultobj;
29982 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29983 PyObject * obj0 = 0 ;
29984 char *kwnames[] = {
29985 (char *) "self", NULL
29986 };
29987
29988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
29989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29990 if (SWIG_arg_fail(1)) SWIG_fail;
29991 {
29992 PyThreadState* __tstate = wxPyBeginAllowThreads();
29993 delete arg1;
29994
29995 wxPyEndAllowThreads(__tstate);
29996 if (PyErr_Occurred()) SWIG_fail;
29997 }
29998 Py_INCREF(Py_None); resultobj = Py_None;
29999 return resultobj;
30000 fail:
30001 return NULL;
30002 }
30003
30004
30005 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30006 PyObject *resultobj;
30007 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30008 wxVideoMode *arg2 = 0 ;
30009 bool result;
30010 PyObject * obj0 = 0 ;
30011 PyObject * obj1 = 0 ;
30012 char *kwnames[] = {
30013 (char *) "self",(char *) "other", NULL
30014 };
30015
30016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30018 if (SWIG_arg_fail(1)) SWIG_fail;
30019 {
30020 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30021 if (SWIG_arg_fail(2)) SWIG_fail;
30022 if (arg2 == NULL) {
30023 SWIG_null_ref("wxVideoMode");
30024 }
30025 if (SWIG_arg_fail(2)) SWIG_fail;
30026 }
30027 {
30028 PyThreadState* __tstate = wxPyBeginAllowThreads();
30029 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30030
30031 wxPyEndAllowThreads(__tstate);
30032 if (PyErr_Occurred()) SWIG_fail;
30033 }
30034 {
30035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30036 }
30037 return resultobj;
30038 fail:
30039 return NULL;
30040 }
30041
30042
30043 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30044 PyObject *resultobj;
30045 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30046 int result;
30047 PyObject * obj0 = 0 ;
30048 char *kwnames[] = {
30049 (char *) "self", NULL
30050 };
30051
30052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30054 if (SWIG_arg_fail(1)) SWIG_fail;
30055 {
30056 PyThreadState* __tstate = wxPyBeginAllowThreads();
30057 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30058
30059 wxPyEndAllowThreads(__tstate);
30060 if (PyErr_Occurred()) SWIG_fail;
30061 }
30062 {
30063 resultobj = SWIG_From_int((int)(result));
30064 }
30065 return resultobj;
30066 fail:
30067 return NULL;
30068 }
30069
30070
30071 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30072 PyObject *resultobj;
30073 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30074 int result;
30075 PyObject * obj0 = 0 ;
30076 char *kwnames[] = {
30077 (char *) "self", NULL
30078 };
30079
30080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30082 if (SWIG_arg_fail(1)) SWIG_fail;
30083 {
30084 PyThreadState* __tstate = wxPyBeginAllowThreads();
30085 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30086
30087 wxPyEndAllowThreads(__tstate);
30088 if (PyErr_Occurred()) SWIG_fail;
30089 }
30090 {
30091 resultobj = SWIG_From_int((int)(result));
30092 }
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30100 PyObject *resultobj;
30101 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30102 int result;
30103 PyObject * obj0 = 0 ;
30104 char *kwnames[] = {
30105 (char *) "self", NULL
30106 };
30107
30108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30110 if (SWIG_arg_fail(1)) SWIG_fail;
30111 {
30112 PyThreadState* __tstate = wxPyBeginAllowThreads();
30113 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30114
30115 wxPyEndAllowThreads(__tstate);
30116 if (PyErr_Occurred()) SWIG_fail;
30117 }
30118 {
30119 resultobj = SWIG_From_int((int)(result));
30120 }
30121 return resultobj;
30122 fail:
30123 return NULL;
30124 }
30125
30126
30127 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30128 PyObject *resultobj;
30129 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30130 bool result;
30131 PyObject * obj0 = 0 ;
30132 char *kwnames[] = {
30133 (char *) "self", NULL
30134 };
30135
30136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30138 if (SWIG_arg_fail(1)) SWIG_fail;
30139 {
30140 PyThreadState* __tstate = wxPyBeginAllowThreads();
30141 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30142
30143 wxPyEndAllowThreads(__tstate);
30144 if (PyErr_Occurred()) SWIG_fail;
30145 }
30146 {
30147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30148 }
30149 return resultobj;
30150 fail:
30151 return NULL;
30152 }
30153
30154
30155 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30156 PyObject *resultobj;
30157 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30158 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30159 bool result;
30160 PyObject * obj0 = 0 ;
30161 PyObject * obj1 = 0 ;
30162 char *kwnames[] = {
30163 (char *) "self",(char *) "other", NULL
30164 };
30165
30166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30168 if (SWIG_arg_fail(1)) SWIG_fail;
30169 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30170 if (SWIG_arg_fail(2)) SWIG_fail;
30171 {
30172 PyThreadState* __tstate = wxPyBeginAllowThreads();
30173 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30174
30175 wxPyEndAllowThreads(__tstate);
30176 if (PyErr_Occurred()) SWIG_fail;
30177 }
30178 {
30179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30180 }
30181 return resultobj;
30182 fail:
30183 return NULL;
30184 }
30185
30186
30187 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30188 PyObject *resultobj;
30189 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30190 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30191 bool result;
30192 PyObject * obj0 = 0 ;
30193 PyObject * obj1 = 0 ;
30194 char *kwnames[] = {
30195 (char *) "self",(char *) "other", NULL
30196 };
30197
30198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30200 if (SWIG_arg_fail(1)) SWIG_fail;
30201 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30202 if (SWIG_arg_fail(2)) SWIG_fail;
30203 {
30204 PyThreadState* __tstate = wxPyBeginAllowThreads();
30205 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30206
30207 wxPyEndAllowThreads(__tstate);
30208 if (PyErr_Occurred()) SWIG_fail;
30209 }
30210 {
30211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30212 }
30213 return resultobj;
30214 fail:
30215 return NULL;
30216 }
30217
30218
30219 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30220 PyObject *resultobj;
30221 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30222 int arg2 ;
30223 PyObject * obj0 = 0 ;
30224 PyObject * obj1 = 0 ;
30225 char *kwnames[] = {
30226 (char *) "self",(char *) "w", NULL
30227 };
30228
30229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30231 if (SWIG_arg_fail(1)) SWIG_fail;
30232 {
30233 arg2 = (int)(SWIG_As_int(obj1));
30234 if (SWIG_arg_fail(2)) SWIG_fail;
30235 }
30236 if (arg1) (arg1)->w = arg2;
30237
30238 Py_INCREF(Py_None); resultobj = Py_None;
30239 return resultobj;
30240 fail:
30241 return NULL;
30242 }
30243
30244
30245 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30246 PyObject *resultobj;
30247 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30248 int result;
30249 PyObject * obj0 = 0 ;
30250 char *kwnames[] = {
30251 (char *) "self", NULL
30252 };
30253
30254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30256 if (SWIG_arg_fail(1)) SWIG_fail;
30257 result = (int) ((arg1)->w);
30258
30259 {
30260 resultobj = SWIG_From_int((int)(result));
30261 }
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj;
30270 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30271 int arg2 ;
30272 PyObject * obj0 = 0 ;
30273 PyObject * obj1 = 0 ;
30274 char *kwnames[] = {
30275 (char *) "self",(char *) "h", NULL
30276 };
30277
30278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30280 if (SWIG_arg_fail(1)) SWIG_fail;
30281 {
30282 arg2 = (int)(SWIG_As_int(obj1));
30283 if (SWIG_arg_fail(2)) SWIG_fail;
30284 }
30285 if (arg1) (arg1)->h = arg2;
30286
30287 Py_INCREF(Py_None); resultobj = Py_None;
30288 return resultobj;
30289 fail:
30290 return NULL;
30291 }
30292
30293
30294 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30295 PyObject *resultobj;
30296 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30297 int result;
30298 PyObject * obj0 = 0 ;
30299 char *kwnames[] = {
30300 (char *) "self", NULL
30301 };
30302
30303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30305 if (SWIG_arg_fail(1)) SWIG_fail;
30306 result = (int) ((arg1)->h);
30307
30308 {
30309 resultobj = SWIG_From_int((int)(result));
30310 }
30311 return resultobj;
30312 fail:
30313 return NULL;
30314 }
30315
30316
30317 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30318 PyObject *resultobj;
30319 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30320 int arg2 ;
30321 PyObject * obj0 = 0 ;
30322 PyObject * obj1 = 0 ;
30323 char *kwnames[] = {
30324 (char *) "self",(char *) "bpp", NULL
30325 };
30326
30327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30329 if (SWIG_arg_fail(1)) SWIG_fail;
30330 {
30331 arg2 = (int)(SWIG_As_int(obj1));
30332 if (SWIG_arg_fail(2)) SWIG_fail;
30333 }
30334 if (arg1) (arg1)->bpp = arg2;
30335
30336 Py_INCREF(Py_None); resultobj = Py_None;
30337 return resultobj;
30338 fail:
30339 return NULL;
30340 }
30341
30342
30343 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30344 PyObject *resultobj;
30345 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30346 int result;
30347 PyObject * obj0 = 0 ;
30348 char *kwnames[] = {
30349 (char *) "self", NULL
30350 };
30351
30352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30354 if (SWIG_arg_fail(1)) SWIG_fail;
30355 result = (int) ((arg1)->bpp);
30356
30357 {
30358 resultobj = SWIG_From_int((int)(result));
30359 }
30360 return resultobj;
30361 fail:
30362 return NULL;
30363 }
30364
30365
30366 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30367 PyObject *resultobj;
30368 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30369 int arg2 ;
30370 PyObject * obj0 = 0 ;
30371 PyObject * obj1 = 0 ;
30372 char *kwnames[] = {
30373 (char *) "self",(char *) "refresh", NULL
30374 };
30375
30376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30378 if (SWIG_arg_fail(1)) SWIG_fail;
30379 {
30380 arg2 = (int)(SWIG_As_int(obj1));
30381 if (SWIG_arg_fail(2)) SWIG_fail;
30382 }
30383 if (arg1) (arg1)->refresh = arg2;
30384
30385 Py_INCREF(Py_None); resultobj = Py_None;
30386 return resultobj;
30387 fail:
30388 return NULL;
30389 }
30390
30391
30392 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30393 PyObject *resultobj;
30394 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30395 int result;
30396 PyObject * obj0 = 0 ;
30397 char *kwnames[] = {
30398 (char *) "self", NULL
30399 };
30400
30401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30403 if (SWIG_arg_fail(1)) SWIG_fail;
30404 result = (int) ((arg1)->refresh);
30405
30406 {
30407 resultobj = SWIG_From_int((int)(result));
30408 }
30409 return resultobj;
30410 fail:
30411 return NULL;
30412 }
30413
30414
30415 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30416 PyObject *obj;
30417 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30418 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30419 Py_INCREF(obj);
30420 return Py_BuildValue((char *)"");
30421 }
30422 static int _wrap_DefaultVideoMode_set(PyObject *) {
30423 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30424 return 1;
30425 }
30426
30427
30428 static PyObject *_wrap_DefaultVideoMode_get(void) {
30429 PyObject *pyobj;
30430
30431 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30432 return pyobj;
30433 }
30434
30435
30436 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30437 PyObject *resultobj;
30438 size_t arg1 = (size_t) 0 ;
30439 wxDisplay *result;
30440 PyObject * obj0 = 0 ;
30441 char *kwnames[] = {
30442 (char *) "index", NULL
30443 };
30444
30445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30446 if (obj0) {
30447 {
30448 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30449 if (SWIG_arg_fail(1)) SWIG_fail;
30450 }
30451 }
30452 {
30453 PyThreadState* __tstate = wxPyBeginAllowThreads();
30454 result = (wxDisplay *)new wxDisplay(arg1);
30455
30456 wxPyEndAllowThreads(__tstate);
30457 if (PyErr_Occurred()) SWIG_fail;
30458 }
30459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30460 return resultobj;
30461 fail:
30462 return NULL;
30463 }
30464
30465
30466 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30467 PyObject *resultobj;
30468 wxDisplay *arg1 = (wxDisplay *) 0 ;
30469 PyObject * obj0 = 0 ;
30470 char *kwnames[] = {
30471 (char *) "self", NULL
30472 };
30473
30474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30476 if (SWIG_arg_fail(1)) SWIG_fail;
30477 {
30478 PyThreadState* __tstate = wxPyBeginAllowThreads();
30479 delete arg1;
30480
30481 wxPyEndAllowThreads(__tstate);
30482 if (PyErr_Occurred()) SWIG_fail;
30483 }
30484 Py_INCREF(Py_None); resultobj = Py_None;
30485 return resultobj;
30486 fail:
30487 return NULL;
30488 }
30489
30490
30491 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30492 PyObject *resultobj;
30493 size_t result;
30494 char *kwnames[] = {
30495 NULL
30496 };
30497
30498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30499 {
30500 PyThreadState* __tstate = wxPyBeginAllowThreads();
30501 result = (size_t)wxDisplay::GetCount();
30502
30503 wxPyEndAllowThreads(__tstate);
30504 if (PyErr_Occurred()) SWIG_fail;
30505 }
30506 {
30507 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30508 }
30509 return resultobj;
30510 fail:
30511 return NULL;
30512 }
30513
30514
30515 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30516 PyObject *resultobj;
30517 wxPoint *arg1 = 0 ;
30518 int result;
30519 wxPoint temp1 ;
30520 PyObject * obj0 = 0 ;
30521 char *kwnames[] = {
30522 (char *) "pt", NULL
30523 };
30524
30525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30526 {
30527 arg1 = &temp1;
30528 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30529 }
30530 {
30531 PyThreadState* __tstate = wxPyBeginAllowThreads();
30532 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30533
30534 wxPyEndAllowThreads(__tstate);
30535 if (PyErr_Occurred()) SWIG_fail;
30536 }
30537 {
30538 resultobj = SWIG_From_int((int)(result));
30539 }
30540 return resultobj;
30541 fail:
30542 return NULL;
30543 }
30544
30545
30546 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30547 PyObject *resultobj;
30548 wxWindow *arg1 = (wxWindow *) 0 ;
30549 int result;
30550 PyObject * obj0 = 0 ;
30551 char *kwnames[] = {
30552 (char *) "window", NULL
30553 };
30554
30555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30557 if (SWIG_arg_fail(1)) SWIG_fail;
30558 {
30559 PyThreadState* __tstate = wxPyBeginAllowThreads();
30560 result = (int)Display_GetFromWindow(arg1);
30561
30562 wxPyEndAllowThreads(__tstate);
30563 if (PyErr_Occurred()) SWIG_fail;
30564 }
30565 {
30566 resultobj = SWIG_From_int((int)(result));
30567 }
30568 return resultobj;
30569 fail:
30570 return NULL;
30571 }
30572
30573
30574 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30575 PyObject *resultobj;
30576 wxDisplay *arg1 = (wxDisplay *) 0 ;
30577 bool result;
30578 PyObject * obj0 = 0 ;
30579 char *kwnames[] = {
30580 (char *) "self", NULL
30581 };
30582
30583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30585 if (SWIG_arg_fail(1)) SWIG_fail;
30586 {
30587 PyThreadState* __tstate = wxPyBeginAllowThreads();
30588 result = (bool)((wxDisplay const *)arg1)->IsOk();
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_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30603 PyObject *resultobj;
30604 wxDisplay *arg1 = (wxDisplay *) 0 ;
30605 wxRect result;
30606 PyObject * obj0 = 0 ;
30607 char *kwnames[] = {
30608 (char *) "self", NULL
30609 };
30610
30611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30613 if (SWIG_arg_fail(1)) SWIG_fail;
30614 {
30615 PyThreadState* __tstate = wxPyBeginAllowThreads();
30616 result = ((wxDisplay const *)arg1)->GetGeometry();
30617
30618 wxPyEndAllowThreads(__tstate);
30619 if (PyErr_Occurred()) SWIG_fail;
30620 }
30621 {
30622 wxRect * resultptr;
30623 resultptr = new wxRect((wxRect &)(result));
30624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30625 }
30626 return resultobj;
30627 fail:
30628 return NULL;
30629 }
30630
30631
30632 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30633 PyObject *resultobj;
30634 wxDisplay *arg1 = (wxDisplay *) 0 ;
30635 wxString result;
30636 PyObject * obj0 = 0 ;
30637 char *kwnames[] = {
30638 (char *) "self", NULL
30639 };
30640
30641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30643 if (SWIG_arg_fail(1)) SWIG_fail;
30644 {
30645 PyThreadState* __tstate = wxPyBeginAllowThreads();
30646 result = ((wxDisplay const *)arg1)->GetName();
30647
30648 wxPyEndAllowThreads(__tstate);
30649 if (PyErr_Occurred()) SWIG_fail;
30650 }
30651 {
30652 #if wxUSE_UNICODE
30653 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30654 #else
30655 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30656 #endif
30657 }
30658 return resultobj;
30659 fail:
30660 return NULL;
30661 }
30662
30663
30664 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30665 PyObject *resultobj;
30666 wxDisplay *arg1 = (wxDisplay *) 0 ;
30667 bool result;
30668 PyObject * obj0 = 0 ;
30669 char *kwnames[] = {
30670 (char *) "self", NULL
30671 };
30672
30673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30675 if (SWIG_arg_fail(1)) SWIG_fail;
30676 {
30677 PyThreadState* __tstate = wxPyBeginAllowThreads();
30678 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30679
30680 wxPyEndAllowThreads(__tstate);
30681 if (PyErr_Occurred()) SWIG_fail;
30682 }
30683 {
30684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30685 }
30686 return resultobj;
30687 fail:
30688 return NULL;
30689 }
30690
30691
30692 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30693 PyObject *resultobj;
30694 wxDisplay *arg1 = (wxDisplay *) 0 ;
30695 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30696 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30697 PyObject *result;
30698 PyObject * obj0 = 0 ;
30699 PyObject * obj1 = 0 ;
30700 char *kwnames[] = {
30701 (char *) "self",(char *) "mode", NULL
30702 };
30703
30704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30706 if (SWIG_arg_fail(1)) SWIG_fail;
30707 if (obj1) {
30708 {
30709 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30710 if (SWIG_arg_fail(2)) SWIG_fail;
30711 if (arg2 == NULL) {
30712 SWIG_null_ref("wxVideoMode");
30713 }
30714 if (SWIG_arg_fail(2)) SWIG_fail;
30715 }
30716 }
30717 {
30718 PyThreadState* __tstate = wxPyBeginAllowThreads();
30719 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30720
30721 wxPyEndAllowThreads(__tstate);
30722 if (PyErr_Occurred()) SWIG_fail;
30723 }
30724 resultobj = result;
30725 return resultobj;
30726 fail:
30727 return NULL;
30728 }
30729
30730
30731 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30732 PyObject *resultobj;
30733 wxDisplay *arg1 = (wxDisplay *) 0 ;
30734 wxVideoMode result;
30735 PyObject * obj0 = 0 ;
30736 char *kwnames[] = {
30737 (char *) "self", NULL
30738 };
30739
30740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30742 if (SWIG_arg_fail(1)) SWIG_fail;
30743 {
30744 PyThreadState* __tstate = wxPyBeginAllowThreads();
30745 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30746
30747 wxPyEndAllowThreads(__tstate);
30748 if (PyErr_Occurred()) SWIG_fail;
30749 }
30750 {
30751 wxVideoMode * resultptr;
30752 resultptr = new wxVideoMode((wxVideoMode &)(result));
30753 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30754 }
30755 return resultobj;
30756 fail:
30757 return NULL;
30758 }
30759
30760
30761 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30762 PyObject *resultobj;
30763 wxDisplay *arg1 = (wxDisplay *) 0 ;
30764 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30765 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30766 bool result;
30767 PyObject * obj0 = 0 ;
30768 PyObject * obj1 = 0 ;
30769 char *kwnames[] = {
30770 (char *) "self",(char *) "mode", NULL
30771 };
30772
30773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30775 if (SWIG_arg_fail(1)) SWIG_fail;
30776 if (obj1) {
30777 {
30778 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30779 if (SWIG_arg_fail(2)) SWIG_fail;
30780 if (arg2 == NULL) {
30781 SWIG_null_ref("wxVideoMode");
30782 }
30783 if (SWIG_arg_fail(2)) SWIG_fail;
30784 }
30785 }
30786 {
30787 PyThreadState* __tstate = wxPyBeginAllowThreads();
30788 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30789
30790 wxPyEndAllowThreads(__tstate);
30791 if (PyErr_Occurred()) SWIG_fail;
30792 }
30793 {
30794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30795 }
30796 return resultobj;
30797 fail:
30798 return NULL;
30799 }
30800
30801
30802 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30803 PyObject *resultobj;
30804 wxDisplay *arg1 = (wxDisplay *) 0 ;
30805 PyObject * obj0 = 0 ;
30806 char *kwnames[] = {
30807 (char *) "self", NULL
30808 };
30809
30810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30812 if (SWIG_arg_fail(1)) SWIG_fail;
30813 {
30814 PyThreadState* __tstate = wxPyBeginAllowThreads();
30815 (arg1)->ResetMode();
30816
30817 wxPyEndAllowThreads(__tstate);
30818 if (PyErr_Occurred()) SWIG_fail;
30819 }
30820 Py_INCREF(Py_None); resultobj = Py_None;
30821 return resultobj;
30822 fail:
30823 return NULL;
30824 }
30825
30826
30827 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30828 PyObject *obj;
30829 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30830 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30831 Py_INCREF(obj);
30832 return Py_BuildValue((char *)"");
30833 }
30834 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30835 PyObject *resultobj;
30836 wxStandardPaths *result;
30837 char *kwnames[] = {
30838 NULL
30839 };
30840
30841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30842 {
30843 PyThreadState* __tstate = wxPyBeginAllowThreads();
30844 result = (wxStandardPaths *)StandardPaths_Get();
30845
30846 wxPyEndAllowThreads(__tstate);
30847 if (PyErr_Occurred()) SWIG_fail;
30848 }
30849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30850 return resultobj;
30851 fail:
30852 return NULL;
30853 }
30854
30855
30856 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30857 PyObject *resultobj;
30858 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30859 wxString result;
30860 PyObject * obj0 = 0 ;
30861 char *kwnames[] = {
30862 (char *) "self", NULL
30863 };
30864
30865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30867 if (SWIG_arg_fail(1)) SWIG_fail;
30868 {
30869 PyThreadState* __tstate = wxPyBeginAllowThreads();
30870 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30871
30872 wxPyEndAllowThreads(__tstate);
30873 if (PyErr_Occurred()) SWIG_fail;
30874 }
30875 {
30876 #if wxUSE_UNICODE
30877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30878 #else
30879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30880 #endif
30881 }
30882 return resultobj;
30883 fail:
30884 return NULL;
30885 }
30886
30887
30888 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30889 PyObject *resultobj;
30890 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30891 wxString result;
30892 PyObject * obj0 = 0 ;
30893 char *kwnames[] = {
30894 (char *) "self", NULL
30895 };
30896
30897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
30898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30899 if (SWIG_arg_fail(1)) SWIG_fail;
30900 {
30901 PyThreadState* __tstate = wxPyBeginAllowThreads();
30902 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
30903
30904 wxPyEndAllowThreads(__tstate);
30905 if (PyErr_Occurred()) SWIG_fail;
30906 }
30907 {
30908 #if wxUSE_UNICODE
30909 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30910 #else
30911 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30912 #endif
30913 }
30914 return resultobj;
30915 fail:
30916 return NULL;
30917 }
30918
30919
30920 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30921 PyObject *resultobj;
30922 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30923 wxString result;
30924 PyObject * obj0 = 0 ;
30925 char *kwnames[] = {
30926 (char *) "self", NULL
30927 };
30928
30929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
30930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30931 if (SWIG_arg_fail(1)) SWIG_fail;
30932 {
30933 PyThreadState* __tstate = wxPyBeginAllowThreads();
30934 result = ((wxStandardPaths const *)arg1)->GetDataDir();
30935
30936 wxPyEndAllowThreads(__tstate);
30937 if (PyErr_Occurred()) SWIG_fail;
30938 }
30939 {
30940 #if wxUSE_UNICODE
30941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30942 #else
30943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30944 #endif
30945 }
30946 return resultobj;
30947 fail:
30948 return NULL;
30949 }
30950
30951
30952 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30953 PyObject *resultobj;
30954 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30955 wxString result;
30956 PyObject * obj0 = 0 ;
30957 char *kwnames[] = {
30958 (char *) "self", NULL
30959 };
30960
30961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
30962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30963 if (SWIG_arg_fail(1)) SWIG_fail;
30964 {
30965 PyThreadState* __tstate = wxPyBeginAllowThreads();
30966 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
30967
30968 wxPyEndAllowThreads(__tstate);
30969 if (PyErr_Occurred()) SWIG_fail;
30970 }
30971 {
30972 #if wxUSE_UNICODE
30973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30974 #else
30975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30976 #endif
30977 }
30978 return resultobj;
30979 fail:
30980 return NULL;
30981 }
30982
30983
30984 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30985 PyObject *resultobj;
30986 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30987 wxString result;
30988 PyObject * obj0 = 0 ;
30989 char *kwnames[] = {
30990 (char *) "self", NULL
30991 };
30992
30993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
30994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30995 if (SWIG_arg_fail(1)) SWIG_fail;
30996 {
30997 PyThreadState* __tstate = wxPyBeginAllowThreads();
30998 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
30999
31000 wxPyEndAllowThreads(__tstate);
31001 if (PyErr_Occurred()) SWIG_fail;
31002 }
31003 {
31004 #if wxUSE_UNICODE
31005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31006 #else
31007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31008 #endif
31009 }
31010 return resultobj;
31011 fail:
31012 return NULL;
31013 }
31014
31015
31016 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31017 PyObject *resultobj;
31018 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31019 wxString result;
31020 PyObject * obj0 = 0 ;
31021 char *kwnames[] = {
31022 (char *) "self", NULL
31023 };
31024
31025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31027 if (SWIG_arg_fail(1)) SWIG_fail;
31028 {
31029 PyThreadState* __tstate = wxPyBeginAllowThreads();
31030 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31031
31032 wxPyEndAllowThreads(__tstate);
31033 if (PyErr_Occurred()) SWIG_fail;
31034 }
31035 {
31036 #if wxUSE_UNICODE
31037 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31038 #else
31039 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31040 #endif
31041 }
31042 return resultobj;
31043 fail:
31044 return NULL;
31045 }
31046
31047
31048 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31049 PyObject *resultobj;
31050 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31051 wxString result;
31052 PyObject * obj0 = 0 ;
31053 char *kwnames[] = {
31054 (char *) "self", NULL
31055 };
31056
31057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31059 if (SWIG_arg_fail(1)) SWIG_fail;
31060 {
31061 PyThreadState* __tstate = wxPyBeginAllowThreads();
31062 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31063
31064 wxPyEndAllowThreads(__tstate);
31065 if (PyErr_Occurred()) SWIG_fail;
31066 }
31067 {
31068 #if wxUSE_UNICODE
31069 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31070 #else
31071 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31072 #endif
31073 }
31074 return resultobj;
31075 fail:
31076 return NULL;
31077 }
31078
31079
31080 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31081 PyObject *resultobj;
31082 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31083 wxString *arg2 = 0 ;
31084 bool temp2 = false ;
31085 PyObject * obj0 = 0 ;
31086 PyObject * obj1 = 0 ;
31087 char *kwnames[] = {
31088 (char *) "self",(char *) "prefix", NULL
31089 };
31090
31091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31093 if (SWIG_arg_fail(1)) SWIG_fail;
31094 {
31095 arg2 = wxString_in_helper(obj1);
31096 if (arg2 == NULL) SWIG_fail;
31097 temp2 = true;
31098 }
31099 {
31100 PyThreadState* __tstate = wxPyBeginAllowThreads();
31101 (arg1)->SetInstallPrefix((wxString const &)*arg2);
31102
31103 wxPyEndAllowThreads(__tstate);
31104 if (PyErr_Occurred()) SWIG_fail;
31105 }
31106 Py_INCREF(Py_None); resultobj = Py_None;
31107 {
31108 if (temp2)
31109 delete arg2;
31110 }
31111 return resultobj;
31112 fail:
31113 {
31114 if (temp2)
31115 delete arg2;
31116 }
31117 return NULL;
31118 }
31119
31120
31121 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31122 PyObject *resultobj;
31123 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31124 wxString result;
31125 PyObject * obj0 = 0 ;
31126 char *kwnames[] = {
31127 (char *) "self", NULL
31128 };
31129
31130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31132 if (SWIG_arg_fail(1)) SWIG_fail;
31133 {
31134 PyThreadState* __tstate = wxPyBeginAllowThreads();
31135 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
31136
31137 wxPyEndAllowThreads(__tstate);
31138 if (PyErr_Occurred()) SWIG_fail;
31139 }
31140 {
31141 #if wxUSE_UNICODE
31142 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31143 #else
31144 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31145 #endif
31146 }
31147 return resultobj;
31148 fail:
31149 return NULL;
31150 }
31151
31152
31153 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31154 PyObject *obj;
31155 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31156 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31157 Py_INCREF(obj);
31158 return Py_BuildValue((char *)"");
31159 }
31160 static PyMethodDef SwigMethods[] = {
31161 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31162 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31163 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31164 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31165 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31166 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31167 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31168 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31169 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31170 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31171 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31172 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31173 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31174 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31175 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31176 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31177 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31178 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31179 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31180 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31181 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31182 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31183 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31184 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31185 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31186 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31187 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31188 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31189 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31190 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31191 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31192 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31193 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31194 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31195 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31196 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31197 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31198 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31199 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31200 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31201 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31202 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31203 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31204 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31205 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31206 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31207 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31208 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31209 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31210 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31211 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31212 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31213 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31214 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31215 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31216 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31217 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31218 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31219 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31220 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31221 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31222 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31223 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31224 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31225 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31226 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31227 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31228 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31229 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31235 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31238 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31239 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31240 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31241 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31243 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31244 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31245 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31246 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31247 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31250 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31251 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31252 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31253 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31254 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31255 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31256 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31257 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31258 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31259 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31260 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31261 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31262 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31263 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31264 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31265 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31266 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31267 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31268 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31269 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31270 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31271 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31272 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31273 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31274 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31275 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31277 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31280 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31281 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31283 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31286 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31287 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31290 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31293 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31294 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31300 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31302 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31304 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31305 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31306 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31308 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31309 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31317 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31318 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31321 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31322 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31325 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31326 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31329 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31339 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31356 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31358 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31360 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31362 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31369 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31375 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31389 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31393 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31396 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31413 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31421 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31468 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31486 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31496 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31512 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31528 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31542 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31551 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31594 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31597 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31600 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31604 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31697 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31698 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31699 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31700 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31717 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31762 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31796 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31804 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31805 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31810 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31819 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31826 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31829 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31832 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31837 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31840 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31844 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31847 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31851 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
31852 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31856 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31860 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31862 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31872 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31883 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
31891 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
31899 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
31913 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
31917 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
31935 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
31949 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
31960 { NULL, NULL, 0, NULL }
31961 };
31962
31963
31964 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31965
31966 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
31967 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
31968 }
31969 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
31970 return (void *)((wxEvent *) ((wxMenuEvent *) x));
31971 }
31972 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
31973 return (void *)((wxEvent *) ((wxCloseEvent *) x));
31974 }
31975 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
31976 return (void *)((wxEvent *) ((wxMouseEvent *) x));
31977 }
31978 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
31979 return (void *)((wxEvent *) ((wxEraseEvent *) x));
31980 }
31981 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
31982 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
31983 }
31984 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
31985 return (void *)((wxEvent *) ((wxTimerEvent *) x));
31986 }
31987 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
31988 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
31989 }
31990 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
31991 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
31992 }
31993 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
31994 return (void *)((wxEvent *) ((wxPyEvent *) x));
31995 }
31996 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
31997 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
31998 }
31999 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32000 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32001 }
32002 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32003 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32004 }
32005 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32006 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32007 }
32008 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32009 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32010 }
32011 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32012 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32013 }
32014 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32015 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32016 }
32017 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32018 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32019 }
32020 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32021 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32022 }
32023 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32024 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32025 }
32026 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32027 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32028 }
32029 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32030 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32031 }
32032 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32033 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32034 }
32035 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32036 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32037 }
32038 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32039 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32040 }
32041 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32042 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32043 }
32044 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32045 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32046 }
32047 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32048 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32049 }
32050 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32051 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32052 }
32053 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32054 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32055 }
32056 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32057 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32058 }
32059 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32060 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32061 }
32062 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32063 return (void *)((wxEvent *) ((wxShowEvent *) x));
32064 }
32065 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32066 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32067 }
32068 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32069 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32070 }
32071 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32072 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32073 }
32074 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32075 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32076 }
32077 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32078 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32079 }
32080 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32081 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32082 }
32083 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32084 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32085 }
32086 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32087 return (void *)((wxConfigBase *) ((wxConfig *) x));
32088 }
32089 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32090 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32091 }
32092 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32093 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32094 }
32095 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32096 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32097 }
32098 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32099 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32100 }
32101 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32102 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32103 }
32104 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32105 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32106 }
32107 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32108 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32109 }
32110 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32111 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32112 }
32113 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32114 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32115 }
32116 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32117 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32118 }
32119 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32120 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32121 }
32122 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32123 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32124 }
32125 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32126 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32127 }
32128 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32129 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32130 }
32131 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32132 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32133 }
32134 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32135 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32136 }
32137 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32138 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32139 }
32140 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32141 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32142 }
32143 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32144 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32145 }
32146 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32147 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32148 }
32149 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32150 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32151 }
32152 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32153 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32154 }
32155 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32156 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32157 }
32158 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32159 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32160 }
32161 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32162 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32163 }
32164 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32165 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32166 }
32167 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32168 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32169 }
32170 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32171 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32172 }
32173 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32174 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32175 }
32176 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32177 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32178 }
32179 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32180 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32181 }
32182 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32183 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32184 }
32185 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32186 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32187 }
32188 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32189 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32190 }
32191 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32192 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32193 }
32194 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32195 return (void *)((wxObject *) ((wxSizerItem *) x));
32196 }
32197 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32198 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32199 }
32200 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32201 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32202 }
32203 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32204 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32205 }
32206 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32207 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32208 }
32209 static void *_p_wxSizerTo_p_wxObject(void *x) {
32210 return (void *)((wxObject *) ((wxSizer *) x));
32211 }
32212 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32213 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32214 }
32215 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32216 return (void *)((wxObject *) ((wxFileHistory *) x));
32217 }
32218 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32219 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32220 }
32221 static void *_p_wxEventTo_p_wxObject(void *x) {
32222 return (void *)((wxObject *) ((wxEvent *) x));
32223 }
32224 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32225 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32226 }
32227 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32228 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32229 }
32230 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32231 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32232 }
32233 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32234 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32235 }
32236 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32237 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32238 }
32239 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32240 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32241 }
32242 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32243 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32244 }
32245 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32246 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32247 }
32248 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32249 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32250 }
32251 static void *_p_wxControlTo_p_wxObject(void *x) {
32252 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32253 }
32254 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32255 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32256 }
32257 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32258 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32259 }
32260 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32261 return (void *)((wxObject *) ((wxFSFile *) x));
32262 }
32263 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32264 return (void *)((wxObject *) ((wxClipboard *) x));
32265 }
32266 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32267 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32268 }
32269 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32270 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32271 }
32272 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32273 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32274 }
32275 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32276 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32277 }
32278 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32279 return (void *)((wxObject *) ((wxToolTip *) x));
32280 }
32281 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32282 return (void *)((wxObject *) ((wxMenuItem *) x));
32283 }
32284 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32285 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32286 }
32287 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32288 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32289 }
32290 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32291 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32292 }
32293 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32294 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32295 }
32296 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32297 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32298 }
32299 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32300 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32301 }
32302 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32303 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32304 }
32305 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32306 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32307 }
32308 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32309 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32310 }
32311 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32312 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32313 }
32314 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32315 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32316 }
32317 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32318 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32319 }
32320 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32321 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32322 }
32323 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32324 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32325 }
32326 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32327 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32328 }
32329 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32330 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32331 }
32332 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32333 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32334 }
32335 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32336 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32337 }
32338 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32339 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32340 }
32341 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32342 return (void *)((wxObject *) ((wxImageHandler *) x));
32343 }
32344 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32345 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32346 }
32347 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32348 return (void *)((wxObject *) ((wxEvtHandler *) x));
32349 }
32350 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32351 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32352 }
32353 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32354 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32355 }
32356 static void *_p_wxImageTo_p_wxObject(void *x) {
32357 return (void *)((wxObject *) ((wxImage *) x));
32358 }
32359 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32360 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32361 }
32362 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32363 return (void *)((wxObject *) ((wxSystemOptions *) x));
32364 }
32365 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32366 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32367 }
32368 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32369 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32370 }
32371 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32372 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32373 }
32374 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32375 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32376 }
32377 static void *_p_wxWindowTo_p_wxObject(void *x) {
32378 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32379 }
32380 static void *_p_wxMenuTo_p_wxObject(void *x) {
32381 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32382 }
32383 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32384 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32385 }
32386 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32387 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32388 }
32389 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32390 return (void *)((wxObject *) ((wxFileSystem *) x));
32391 }
32392 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32393 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32394 }
32395 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32396 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32397 }
32398 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32399 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32400 }
32401 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32402 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32403 }
32404 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32405 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32406 }
32407 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32408 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32409 }
32410 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32411 return (void *)((wxObject *) ((wxBusyInfo *) x));
32412 }
32413 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32414 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32415 }
32416 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32417 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32418 }
32419 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32420 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32421 }
32422 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32423 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32424 }
32425 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32426 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32427 }
32428 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32429 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32430 }
32431 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32432 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32433 }
32434 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32435 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32436 }
32437 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32438 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32439 }
32440 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32441 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32442 }
32443 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32444 return (void *)((wxLog *) ((wxLogStderr *) x));
32445 }
32446 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32447 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32448 }
32449 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32450 return (void *)((wxLog *) ((wxLogWindow *) x));
32451 }
32452 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32453 return (void *)((wxLog *) ((wxLogChain *) x));
32454 }
32455 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32456 return (void *)((wxLog *) ((wxLogGui *) x));
32457 }
32458 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32459 return (void *)((wxLog *) ((wxPyLog *) x));
32460 }
32461 static void *_p_wxControlTo_p_wxWindow(void *x) {
32462 return (void *)((wxWindow *) ((wxControl *) x));
32463 }
32464 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32465 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32466 }
32467 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32468 return (void *)((wxWindow *) ((wxMenuBar *) x));
32469 }
32470 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32471 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32472 }
32473 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32474 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32475 }
32476 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}};
32477 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}};
32478 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}};
32479 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}};
32480 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}};
32481 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}};
32482 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}};
32483 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}};
32484 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}};
32485 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}};
32486 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}};
32487 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}};
32488 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}};
32489 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}};
32490 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}};
32491 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}};
32492 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}};
32493 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}};
32494 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}};
32495 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}};
32496 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}};
32497 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}};
32498 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}};
32499 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}};
32500 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}};
32501 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}};
32502 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}};
32503 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}};
32504 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}};
32505 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}};
32506 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}};
32507 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}};
32508 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}};
32509 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}};
32510 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}};
32511 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}};
32512 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}};
32513 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}};
32514 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}};
32515 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}};
32516 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}};
32517 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}};
32518 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}};
32519 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}};
32520 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}};
32521 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}};
32522 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}};
32523 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}};
32524 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}};
32525 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}};
32526 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}};
32527 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}};
32528 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}};
32529 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}};
32530 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}};
32531 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}};
32532 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}};
32533 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}};
32534 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}};
32535 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}};
32536 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}};
32537 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}};
32538 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}};
32539 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}};
32540 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}};
32541 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}};
32542 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}};
32543 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}};
32544 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}};
32545 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}};
32546 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}};
32547 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}};
32548 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}};
32549 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}};
32550 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}};
32551 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}};
32552 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}};
32553 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}};
32554 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}};
32555 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}};
32556 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}};
32557 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}};
32558 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}};
32559 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}};
32560 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}};
32561 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}};
32562 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}};
32563 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}};
32564 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}};
32565 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}};
32566 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}};
32567 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}};
32568 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}};
32569 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}};
32570 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}};
32571
32572 static swig_type_info *swig_types_initial[] = {
32573 _swigt__p_wxLogChain,
32574 _swigt__p_wxMutexGuiLocker,
32575 _swigt__p_wxFileHistory,
32576 _swigt__p_wxLog,
32577 _swigt__p_wxMenu,
32578 _swigt__p_wxEvent,
32579 _swigt__p_wxDateTime__TimeZone,
32580 _swigt__p_wxConfigBase,
32581 _swigt__p_wxDisplay,
32582 _swigt__p_wxFileType,
32583 _swigt__p_wxLogGui,
32584 _swigt__p_wxFont,
32585 _swigt__p_wxDataFormat,
32586 _swigt__p_wxTimerEvent,
32587 _swigt__p_wxCaret,
32588 _swigt__ptrdiff_t,
32589 _swigt__std__ptrdiff_t,
32590 _swigt__p_int,
32591 _swigt__p_wxSize,
32592 _swigt__p_wxClipboard,
32593 _swigt__p_wxStopWatch,
32594 _swigt__p_wxClipboardLocker,
32595 _swigt__p_wxIcon,
32596 _swigt__p_wxLogStderr,
32597 _swigt__p_wxLogTextCtrl,
32598 _swigt__p_wxTextCtrl,
32599 _swigt__p_wxBusyCursor,
32600 _swigt__p_wxBitmapDataObject,
32601 _swigt__p_wxTextDataObject,
32602 _swigt__p_wxDataObject,
32603 _swigt__p_wxPyTextDataObject,
32604 _swigt__p_wxPyBitmapDataObject,
32605 _swigt__p_wxFileDataObject,
32606 _swigt__p_wxCustomDataObject,
32607 _swigt__p_wxURLDataObject,
32608 _swigt__p_wxMetafileDataObject,
32609 _swigt__p_wxSound,
32610 _swigt__p_wxTimerRunner,
32611 _swigt__p_wxLogWindow,
32612 _swigt__p_wxTimeSpan,
32613 _swigt__p_wxArrayString,
32614 _swigt__p_wxWindowDisabler,
32615 _swigt__p_form_ops_t,
32616 _swigt__p_wxToolTip,
32617 _swigt__p_wxDataObjectComposite,
32618 _swigt__p_wxFileConfig,
32619 _swigt__p_wxSystemSettings,
32620 _swigt__p_wxVideoMode,
32621 _swigt__p_wxDataObjectSimple,
32622 _swigt__p_wxPyDataObjectSimple,
32623 _swigt__p_wxDuplexMode,
32624 _swigt__p_wxEvtHandler,
32625 _swigt__p_wxRect,
32626 _swigt__p_char,
32627 _swigt__p_wxSingleInstanceChecker,
32628 _swigt__p_wxStandardPaths,
32629 _swigt__p_wxFileTypeInfo,
32630 _swigt__p_wxFrame,
32631 _swigt__p_wxTimer,
32632 _swigt__p_wxPaperSize,
32633 _swigt__p_wxMimeTypesManager,
32634 _swigt__p_wxPyArtProvider,
32635 _swigt__p_wxPyTipProvider,
32636 _swigt__p_wxTipProvider,
32637 _swigt__p_wxJoystick,
32638 _swigt__p_wxSystemOptions,
32639 _swigt__p_wxPoint,
32640 _swigt__p_wxJoystickEvent,
32641 _swigt__p_wxCursor,
32642 _swigt__p_wxObject,
32643 _swigt__p_wxOutputStream,
32644 _swigt__p_wxDateTime,
32645 _swigt__p_wxPyDropSource,
32646 _swigt__p_unsigned_long,
32647 _swigt__p_wxKillError,
32648 _swigt__p_wxWindow,
32649 _swigt__p_wxString,
32650 _swigt__p_wxPyProcess,
32651 _swigt__p_wxBitmap,
32652 _swigt__p_wxConfig,
32653 _swigt__unsigned_int,
32654 _swigt__p_unsigned_int,
32655 _swigt__p_unsigned_char,
32656 _swigt__p_wxChar,
32657 _swigt__p_wxBusyInfo,
32658 _swigt__p_wxPyDropTarget,
32659 _swigt__p_wxPyTextDropTarget,
32660 _swigt__p_wxPyFileDropTarget,
32661 _swigt__p_wxProcessEvent,
32662 _swigt__p_wxPyLog,
32663 _swigt__p_wxLogNull,
32664 _swigt__p_wxColour,
32665 _swigt__p_wxPyTimer,
32666 _swigt__p_wxConfigPathChanger,
32667 _swigt__p_wxDateSpan,
32668 0
32669 };
32670
32671
32672 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32673
32674 static swig_const_info swig_const_table[] = {
32675 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32676 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32677 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32678 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32679 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32680 {0, 0, 0, 0.0, 0, 0}};
32681
32682 #ifdef __cplusplus
32683 }
32684 #endif
32685
32686
32687 #ifdef __cplusplus
32688 extern "C" {
32689 #endif
32690
32691 /* Python-specific SWIG API */
32692 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32693 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32694 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32695
32696 /* -----------------------------------------------------------------------------
32697 * global variable support code.
32698 * ----------------------------------------------------------------------------- */
32699
32700 typedef struct swig_globalvar {
32701 char *name; /* Name of global variable */
32702 PyObject *(*get_attr)(); /* Return the current value */
32703 int (*set_attr)(PyObject *); /* Set the value */
32704 struct swig_globalvar *next;
32705 } swig_globalvar;
32706
32707 typedef struct swig_varlinkobject {
32708 PyObject_HEAD
32709 swig_globalvar *vars;
32710 } swig_varlinkobject;
32711
32712 static PyObject *
32713 swig_varlink_repr(swig_varlinkobject *v) {
32714 v = v;
32715 return PyString_FromString("<Swig global variables>");
32716 }
32717
32718 static int
32719 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32720 swig_globalvar *var;
32721 flags = flags;
32722 fprintf(fp,"Swig global variables { ");
32723 for (var = v->vars; var; var=var->next) {
32724 fprintf(fp,"%s", var->name);
32725 if (var->next) fprintf(fp,", ");
32726 }
32727 fprintf(fp," }\n");
32728 return 0;
32729 }
32730
32731 static PyObject *
32732 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32733 swig_globalvar *var = v->vars;
32734 while (var) {
32735 if (strcmp(var->name,n) == 0) {
32736 return (*var->get_attr)();
32737 }
32738 var = var->next;
32739 }
32740 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32741 return NULL;
32742 }
32743
32744 static int
32745 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32746 swig_globalvar *var = v->vars;
32747 while (var) {
32748 if (strcmp(var->name,n) == 0) {
32749 return (*var->set_attr)(p);
32750 }
32751 var = var->next;
32752 }
32753 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32754 return 1;
32755 }
32756
32757 static PyTypeObject varlinktype = {
32758 PyObject_HEAD_INIT(0)
32759 0, /* Number of items in variable part (ob_size) */
32760 (char *)"swigvarlink", /* Type name (tp_name) */
32761 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32762 0, /* Itemsize (tp_itemsize) */
32763 0, /* Deallocator (tp_dealloc) */
32764 (printfunc) swig_varlink_print, /* Print (tp_print) */
32765 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32766 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32767 0, /* tp_compare */
32768 (reprfunc) swig_varlink_repr, /* tp_repr */
32769 0, /* tp_as_number */
32770 0, /* tp_as_sequence */
32771 0, /* tp_as_mapping */
32772 0, /* tp_hash */
32773 0, /* tp_call */
32774 0, /* tp_str */
32775 0, /* tp_getattro */
32776 0, /* tp_setattro */
32777 0, /* tp_as_buffer */
32778 0, /* tp_flags */
32779 0, /* tp_doc */
32780 #if PY_VERSION_HEX >= 0x02000000
32781 0, /* tp_traverse */
32782 0, /* tp_clear */
32783 #endif
32784 #if PY_VERSION_HEX >= 0x02010000
32785 0, /* tp_richcompare */
32786 0, /* tp_weaklistoffset */
32787 #endif
32788 #if PY_VERSION_HEX >= 0x02020000
32789 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32790 #endif
32791 #if PY_VERSION_HEX >= 0x02030000
32792 0, /* tp_del */
32793 #endif
32794 #ifdef COUNT_ALLOCS
32795 0,0,0,0 /* tp_alloc -> tp_next */
32796 #endif
32797 };
32798
32799 /* Create a variable linking object for use later */
32800 static PyObject *
32801 SWIG_Python_newvarlink(void) {
32802 swig_varlinkobject *result = 0;
32803 result = PyMem_NEW(swig_varlinkobject,1);
32804 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32805 result->ob_type = &varlinktype;
32806 result->vars = 0;
32807 result->ob_refcnt = 0;
32808 Py_XINCREF((PyObject *) result);
32809 return ((PyObject*) result);
32810 }
32811
32812 static void
32813 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32814 swig_varlinkobject *v;
32815 swig_globalvar *gv;
32816 v= (swig_varlinkobject *) p;
32817 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32818 gv->name = (char *) malloc(strlen(name)+1);
32819 strcpy(gv->name,name);
32820 gv->get_attr = get_attr;
32821 gv->set_attr = set_attr;
32822 gv->next = v->vars;
32823 v->vars = gv;
32824 }
32825
32826 /* -----------------------------------------------------------------------------
32827 * constants/methods manipulation
32828 * ----------------------------------------------------------------------------- */
32829
32830 /* Install Constants */
32831 static void
32832 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32833 PyObject *obj = 0;
32834 size_t i;
32835 for (i = 0; constants[i].type; i++) {
32836 switch(constants[i].type) {
32837 case SWIG_PY_INT:
32838 obj = PyInt_FromLong(constants[i].lvalue);
32839 break;
32840 case SWIG_PY_FLOAT:
32841 obj = PyFloat_FromDouble(constants[i].dvalue);
32842 break;
32843 case SWIG_PY_STRING:
32844 if (constants[i].pvalue) {
32845 obj = PyString_FromString((char *) constants[i].pvalue);
32846 } else {
32847 Py_INCREF(Py_None);
32848 obj = Py_None;
32849 }
32850 break;
32851 case SWIG_PY_POINTER:
32852 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32853 break;
32854 case SWIG_PY_BINARY:
32855 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32856 break;
32857 default:
32858 obj = 0;
32859 break;
32860 }
32861 if (obj) {
32862 PyDict_SetItemString(d,constants[i].name,obj);
32863 Py_DECREF(obj);
32864 }
32865 }
32866 }
32867
32868 /* -----------------------------------------------------------------------------*/
32869 /* Fix SwigMethods to carry the callback ptrs when needed */
32870 /* -----------------------------------------------------------------------------*/
32871
32872 static void
32873 SWIG_Python_FixMethods(PyMethodDef *methods,
32874 swig_const_info *const_table,
32875 swig_type_info **types,
32876 swig_type_info **types_initial) {
32877 size_t i;
32878 for (i = 0; methods[i].ml_name; ++i) {
32879 char *c = methods[i].ml_doc;
32880 if (c && (c = strstr(c, "swig_ptr: "))) {
32881 int j;
32882 swig_const_info *ci = 0;
32883 char *name = c + 10;
32884 for (j = 0; const_table[j].type; j++) {
32885 if (strncmp(const_table[j].name, name,
32886 strlen(const_table[j].name)) == 0) {
32887 ci = &(const_table[j]);
32888 break;
32889 }
32890 }
32891 if (ci) {
32892 size_t shift = (ci->ptype) - types;
32893 swig_type_info *ty = types_initial[shift];
32894 size_t ldoc = (c - methods[i].ml_doc);
32895 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32896 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32897 char *buff = ndoc;
32898 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
32899 strncpy(buff, methods[i].ml_doc, ldoc);
32900 buff += ldoc;
32901 strncpy(buff, "swig_ptr: ", 10);
32902 buff += 10;
32903 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32904 methods[i].ml_doc = ndoc;
32905 }
32906 }
32907 }
32908 }
32909
32910 /* -----------------------------------------------------------------------------*
32911 * Initialize type list
32912 * -----------------------------------------------------------------------------*/
32913
32914 #if PY_MAJOR_VERSION < 2
32915 /* PyModule_AddObject function was introduced in Python 2.0. The following function
32916 is copied out of Python/modsupport.c in python version 2.3.4 */
32917 static int
32918 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
32919 {
32920 PyObject *dict;
32921 if (!PyModule_Check(m)) {
32922 PyErr_SetString(PyExc_TypeError,
32923 "PyModule_AddObject() needs module as first arg");
32924 return -1;
32925 }
32926 if (!o) {
32927 PyErr_SetString(PyExc_TypeError,
32928 "PyModule_AddObject() needs non-NULL value");
32929 return -1;
32930 }
32931
32932 dict = PyModule_GetDict(m);
32933 if (dict == NULL) {
32934 /* Internal error -- modules must have a dict! */
32935 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
32936 PyModule_GetName(m));
32937 return -1;
32938 }
32939 if (PyDict_SetItemString(dict, name, o))
32940 return -1;
32941 Py_DECREF(o);
32942 return 0;
32943 }
32944 #endif
32945
32946 static swig_type_info **
32947 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
32948 static PyMethodDef swig_empty_runtime_method_table[] = {
32949 {
32950 NULL, NULL, 0, NULL
32951 }
32952 };/* Sentinel */
32953
32954 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
32955 swig_empty_runtime_method_table);
32956 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
32957 if (pointer && module) {
32958 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
32959 }
32960 return type_list_handle;
32961 }
32962
32963 static swig_type_info **
32964 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
32965 swig_type_info **type_pointer;
32966
32967 /* first check if module already created */
32968 type_pointer = SWIG_Python_GetTypeListHandle();
32969 if (type_pointer) {
32970 return type_pointer;
32971 } else {
32972 /* create a new module and variable */
32973 return SWIG_Python_SetTypeListHandle(type_list_handle);
32974 }
32975 }
32976
32977 #ifdef __cplusplus
32978 }
32979 #endif
32980
32981 /* -----------------------------------------------------------------------------*
32982 * Partial Init method
32983 * -----------------------------------------------------------------------------*/
32984
32985 #ifdef SWIG_LINK_RUNTIME
32986 #ifdef __cplusplus
32987 extern "C"
32988 #endif
32989 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
32990 #endif
32991
32992 #ifdef __cplusplus
32993 extern "C"
32994 #endif
32995 SWIGEXPORT(void) SWIG_init(void) {
32996 static PyObject *SWIG_globals = 0;
32997 static int typeinit = 0;
32998 PyObject *m, *d;
32999 int i;
33000 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33001
33002 /* Fix SwigMethods to carry the callback ptrs when needed */
33003 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33004
33005 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33006 d = PyModule_GetDict(m);
33007
33008 if (!typeinit) {
33009 #ifdef SWIG_LINK_RUNTIME
33010 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33011 #else
33012 # ifndef SWIG_STATIC_RUNTIME
33013 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33014 # endif
33015 #endif
33016 for (i = 0; swig_types_initial[i]; i++) {
33017 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33018 }
33019 typeinit = 1;
33020 }
33021 SWIG_InstallConstants(d,swig_const_table);
33022
33023 {
33024 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33025 }
33026 {
33027 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33028 }
33029 {
33030 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33031 }
33032 {
33033 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33034 }
33035 {
33036 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33037 }
33038 {
33039 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33040 }
33041 {
33042 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33043 }
33044 {
33045 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33046 }
33047 {
33048 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33049 }
33050 {
33051 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33052 }
33053 {
33054 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33055 }
33056 {
33057 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33058 }
33059 {
33060 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33061 }
33062 {
33063 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33064 }
33065 {
33066 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33067 }
33068 {
33069 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33070 }
33071 {
33072 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33073 }
33074 {
33075 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33076 }
33077 {
33078 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33079 }
33080 {
33081 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33082 }
33083 {
33084 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33085 }
33086 {
33087 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33088 }
33089 {
33090 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33091 }
33092 {
33093 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33094 }
33095 {
33096 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33097 }
33098 {
33099 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33100 }
33101 {
33102 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33103 }
33104 {
33105 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33106 }
33107 {
33108 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33109 }
33110 {
33111 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33112 }
33113 {
33114 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33115 }
33116 {
33117 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33118 }
33119 {
33120 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33121 }
33122 {
33123 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33124 }
33125 {
33126 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33127 }
33128 {
33129 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33130 }
33131 {
33132 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33133 }
33134 {
33135 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33136 }
33137 {
33138 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33139 }
33140 {
33141 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33142 }
33143 {
33144 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33145 }
33146 {
33147 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33148 }
33149 {
33150 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33151 }
33152 {
33153 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33154 }
33155 {
33156 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33157 }
33158 {
33159 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33160 }
33161 {
33162 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33163 }
33164 {
33165 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33166 }
33167 {
33168 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33169 }
33170 {
33171 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33172 }
33173 {
33174 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33175 }
33176 {
33177 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33178 }
33179 {
33180 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33181 }
33182 {
33183 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33184 }
33185 {
33186 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33187 }
33188 {
33189 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33190 }
33191 {
33192 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33193 }
33194 {
33195 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33196 }
33197 {
33198 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33199 }
33200 {
33201 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33202 }
33203 {
33204 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33205 }
33206 {
33207 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33208 }
33209 {
33210 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33211 }
33212 {
33213 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33214 }
33215 {
33216 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33217 }
33218 {
33219 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33220 }
33221 {
33222 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33223 }
33224 {
33225 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33226 }
33227 {
33228 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33229 }
33230 {
33231 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33232 }
33233 {
33234 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33235 }
33236 {
33237 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33238 }
33239 {
33240 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33241 }
33242 {
33243 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33244 }
33245 {
33246 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33247 }
33248 {
33249 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33250 }
33251 {
33252 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33253 }
33254 {
33255 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33256 }
33257 {
33258 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33259 }
33260 {
33261 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33262 }
33263 {
33264 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33265 }
33266 {
33267 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33268 }
33269 {
33270 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33271 }
33272 {
33273 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33274 }
33275 {
33276 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33277 }
33278 {
33279 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33280 }
33281 {
33282 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33283 }
33284 {
33285 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33286 }
33287 {
33288 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33289 }
33290 {
33291 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33292 }
33293 {
33294 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33295 }
33296 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33297 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33298 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33299 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33300 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33301 {
33302 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33303 }
33304 {
33305 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33306 }
33307 {
33308 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33309 }
33310 {
33311 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33312 }
33313 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33314
33315 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33316
33317 {
33318 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33319 }
33320 {
33321 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33322 }
33323 {
33324 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33325 }
33326 {
33327 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33328 }
33329 {
33330 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33331 }
33332 {
33333 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33334 }
33335 {
33336 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33337 }
33338 {
33339 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33340 }
33341 {
33342 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33343 }
33344 {
33345 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33346 }
33347 {
33348 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33349 }
33350 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33351 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33352 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33353 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33354 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33355 {
33356 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33357 }
33358 {
33359 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33360 }
33361 {
33362 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33363 }
33364 {
33365 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33366 }
33367 {
33368 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33369 }
33370 {
33371 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33372 }
33373 {
33374 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33375 }
33376 {
33377 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33378 }
33379 {
33380 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33381 }
33382 {
33383 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33384 }
33385 {
33386 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33387 }
33388 {
33389 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33390 }
33391 {
33392 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33393 }
33394 {
33395 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33396 }
33397 {
33398 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33399 }
33400 {
33401 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33402 }
33403 {
33404 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33405 }
33406 {
33407 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33408 }
33409 {
33410 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33411 }
33412 {
33413 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33414 }
33415 {
33416 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33417 }
33418 {
33419 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33420 }
33421 {
33422 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33423 }
33424 {
33425 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33426 }
33427 {
33428 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33429 }
33430 {
33431 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33432 }
33433 {
33434 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33435 }
33436 {
33437 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33438 }
33439 {
33440 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33441 }
33442 {
33443 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33444 }
33445 {
33446 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33447 }
33448 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33449 {
33450 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33463 }
33464
33465 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33466
33467 {
33468 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33469 }
33470 {
33471 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33472 }
33473 {
33474 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33475 }
33476 {
33477 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33478 }
33479 {
33480 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33481 }
33482 {
33483 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33484 }
33485 {
33486 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33487 }
33488 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33489 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33490 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33491 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33492 {
33493 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33515 }
33516 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33517 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33518 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33519 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33520 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33521 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33522 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33523 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33524 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33525 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33526 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33527 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33528 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33529 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33530 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33531 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33532 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33533 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33534 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33535 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33536 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33537 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33538 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33539 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33540 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33541 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33542 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33543 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33544 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33545 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33546 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33547 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33548 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33549 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33550 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33551 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33552 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33553 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33554 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33555 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33556 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33557 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33558 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33559 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33560 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33561 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33562 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33563 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33564 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33565 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33566 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33567 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33568 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33569 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33570 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33571 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33572
33573 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33574
33575 {
33576 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33580 }
33581 {
33582 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33583 }
33584 {
33585 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33589 }
33590 {
33591 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33592 }
33593 {
33594 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33595 }
33596 {
33597 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33598 }
33599 {
33600 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33601 }
33602 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33603 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33604 {
33605 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33606 }
33607 {
33608 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33609 }
33610 {
33611 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33612 }
33613 {
33614 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33615 }
33616 {
33617 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33618 }
33619 {
33620 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33621 }
33622 {
33623 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33624 }
33625 {
33626 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33627 }
33628 {
33629 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33630 }
33631 {
33632 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33633 }
33634 {
33635 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33636 }
33637 {
33638 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33639 }
33640 {
33641 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33642 }
33643 {
33644 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33645 }
33646 {
33647 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33648 }
33649 {
33650 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33651 }
33652 {
33653 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33654 }
33655 {
33656 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33657 }
33658 {
33659 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33660 }
33661 {
33662 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33663 }
33664 {
33665 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33666 }
33667 {
33668 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33669 }
33670 {
33671 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33672 }
33673 {
33674 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33675 }
33676 {
33677 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33678 }
33679 {
33680 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33681 }
33682 {
33683 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33684 }
33685 {
33686 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33687 }
33688 {
33689 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33690 }
33691 {
33692 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33693 }
33694 {
33695 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33696 }
33697 {
33698 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33699 }
33700 {
33701 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33702 }
33703 {
33704 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33705 }
33706 {
33707 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33708 }
33709 {
33710 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33711 }
33712 {
33713 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33714 }
33715 {
33716 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33717 }
33718 {
33719 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33720 }
33721 {
33722 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33723 }
33724 {
33725 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33726 }
33727 {
33728 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33729 }
33730 {
33731 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33732 }
33733 {
33734 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33735 }
33736 {
33737 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33738 }
33739 {
33740 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33741 }
33742 {
33743 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33744 }
33745 {
33746 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33747 }
33748 {
33749 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33750 }
33751 {
33752 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33753 }
33754 {
33755 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33756 }
33757 {
33758 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33759 }
33760 {
33761 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33762 }
33763 {
33764 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33765 }
33766 {
33767 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33768 }
33769 {
33770 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33771 }
33772 {
33773 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33774 }
33775 {
33776 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33777 }
33778 {
33779 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33780 }
33781 {
33782 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33783 }
33784 {
33785 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33786 }
33787 {
33788 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33789 }
33790 {
33791 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33792 }
33793 {
33794 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33795 }
33796 {
33797 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33798 }
33799 {
33800 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33801 }
33802 {
33803 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33804 }
33805 {
33806 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33807 }
33808 {
33809 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33810 }
33811 {
33812 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33813 }
33814 {
33815 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33816 }
33817 {
33818 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33819 }
33820 {
33821 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33822 }
33823 {
33824 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33825 }
33826 {
33827 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33828 }
33829 {
33830 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33831 }
33832 {
33833 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33834 }
33835 {
33836 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33837 }
33838 {
33839 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33840 }
33841 {
33842 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33843 }
33844 {
33845 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33846 }
33847 {
33848 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33849 }
33850 {
33851 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33852 }
33853 {
33854 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33855 }
33856 {
33857 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33858 }
33859 {
33860 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33861 }
33862 {
33863 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33864 }
33865 {
33866 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33867 }
33868 {
33869 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33870 }
33871 {
33872 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33873 }
33874 {
33875 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33876 }
33877 {
33878 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33879 }
33880 {
33881 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33882 }
33883 {
33884 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
33885 }
33886 {
33887 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
33888 }
33889 {
33890 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
33891 }
33892 {
33893 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
33894 }
33895 {
33896 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
33897 }
33898 {
33899 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
33900 }
33901 {
33902 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
33909 }
33910 {
33911 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
33924 }
33925 {
33926 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
33927 }
33928 {
33929 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
33930 }
33931 {
33932 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
33933 }
33934 {
33935 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
33936 }
33937 {
33938 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
33939 }
33940 {
33941 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
33942 }
33943 {
33944 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
33945 }
33946 {
33947 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
33948 }
33949 {
33950 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
33951 }
33952 {
33953 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
33954 }
33955 {
33956 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
33957 }
33958 {
33959 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
33960 }
33961 {
33962 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
33972 }
33973 {
33974 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
33975 }
33976 {
33977 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
33978 }
33979 {
33980 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
33981 }
33982 {
33983 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
33984 }
33985 {
33986 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
33987 }
33988 {
33989 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
33990 }
33991 {
33992 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
33993 }
33994 {
33995 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
33996 }
33997 {
33998 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
33999 }
34000 {
34001 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34002 }
34003 {
34004 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34005 }
34006 {
34007 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34008 }
34009 {
34010 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34011 }
34012 {
34013 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34014 }
34015 {
34016 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34017 }
34018 {
34019 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34020 }
34021 {
34022 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34023 }
34024 {
34025 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34026 }
34027 {
34028 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34029 }
34030 {
34031 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34032 }
34033 {
34034 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34035 }
34036 {
34037 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34038 }
34039 {
34040 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34041 }
34042 {
34043 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34044 }
34045 {
34046 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34047 }
34048 {
34049 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34050 }
34051 {
34052 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34053 }
34054 {
34055 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34056 }
34057 {
34058 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34059 }
34060 {
34061 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34062 }
34063 {
34064 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34065 }
34066 {
34067 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34068 }
34069 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34070 {
34071 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34072 }
34073 {
34074 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34075 }
34076 {
34077 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34078 }
34079 {
34080 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34081 }
34082 {
34083 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34084 }
34085 {
34086 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34087 }
34088 {
34089 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34090 }
34091 {
34092 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34093 }
34094 {
34095 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34096 }
34097 {
34098 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34099 }
34100 {
34101 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34102 }
34103 {
34104 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34105 }
34106 {
34107 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34108 }
34109 {
34110 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34111 }
34112 {
34113 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34114 }
34115 {
34116 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34117 }
34118 {
34119 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34120 }
34121 {
34122 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34123 }
34124 {
34125 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34126 }
34127 {
34128 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34129 }
34130 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34131 {
34132 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34133 }
34134 {
34135 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34136 }
34137 {
34138 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34139 }
34140 {
34141 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34142 }
34143 {
34144 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34145 }
34146 {
34147 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34148 }
34149 {
34150 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34151 }
34152 {
34153 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34154 }
34155 {
34156 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34157 }
34158 {
34159 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34160 }
34161 {
34162 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34163 }
34164 {
34165 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34166 }
34167
34168 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34169 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34170 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34171 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34172
34173 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34174 }
34175
wxWidgets (Impactor)